diff -Nru node-lolex-1.5.1/AUTHORS node-lolex-2.2.0/AUTHORS --- node-lolex-1.5.1/AUTHORS 2016-07-26 15:17:13.000000000 +0000 +++ node-lolex-2.2.0/AUTHORS 2017-11-07 16:28:37.000000000 +0000 @@ -1,15 +1,25 @@ -Christian Johansen Carl-Erik Kopseng +Christian Johansen Morgan Roderick Maximilian Antoni Mark Wubben -Soutaro Matsumoto Duncan Beevers +Soutaro Matsumoto +Benjamin Gruenbaum Rogier Schouten Karl O'Keeffe -Thibault Hild +Elad Nachmias +Clark Tomlinson +Josh Goldberg +Andy Edwards Curtis M. Humphrey, Ph.D +Edward Betts +Kyle Fleming Mark Banner +Nando +Peter A. Bigot Simen Bekkhus Sylvain Fraïssé -Andy Edwards +Thibault Hild +griest024 +mAAdhaTTah diff -Nru node-lolex-1.5.1/debian/changelog node-lolex-2.2.0/debian/changelog --- node-lolex-1.5.1/debian/changelog 2016-10-12 11:44:44.000000000 +0000 +++ node-lolex-2.2.0/debian/changelog 2018-02-10 18:40:08.000000000 +0000 @@ -1,3 +1,11 @@ +node-lolex (2.2.0-1) unstable; urgency=medium + + * Team upload + * New upstream release + * Modernize packaging + + -- Pirate Praveen Sun, 11 Feb 2018 00:10:08 +0530 + node-lolex (1.5.1-1) unstable; urgency=low * Initial release (Closes: #840508) diff -Nru node-lolex-1.5.1/debian/compat node-lolex-2.2.0/debian/compat --- node-lolex-1.5.1/debian/compat 2016-10-12 11:44:44.000000000 +0000 +++ node-lolex-2.2.0/debian/compat 2018-02-10 18:40:08.000000000 +0000 @@ -1 +1 @@ -9 +11 diff -Nru node-lolex-1.5.1/debian/control node-lolex-2.2.0/debian/control --- node-lolex-1.5.1/debian/control 2016-10-12 11:44:44.000000000 +0000 +++ node-lolex-2.2.0/debian/control 2018-02-10 18:40:08.000000000 +0000 @@ -1,13 +1,18 @@ Source: node-lolex -Section: web +Section: javascript Priority: optional Maintainer: Debian Javascript Maintainers Uploaders: Sruthi Chandran Build-Depends: - debhelper (>= 9) + debhelper (>= 11) , dh-buildinfo , nodejs -Standards-Version: 3.9.8 + , mocha + , node-sinon +# , node-referee + , node-lodash + , node-samsam +Standards-Version: 4.1.3 Homepage: http://github.com/sinonjs/lolex Vcs-Git: https://anonscm.debian.org/git/pkg-javascript/node-lolex.git Vcs-Browser: https://anonscm.debian.org/cgit/pkg-javascript/node-lolex.git diff -Nru node-lolex-1.5.1/debian/install node-lolex-2.2.0/debian/install --- node-lolex-1.5.1/debian/install 2016-10-12 11:44:44.000000000 +0000 +++ node-lolex-2.2.0/debian/install 2018-02-02 16:02:03.000000000 +0000 @@ -1,2 +1,3 @@ package.json usr/lib/nodejs/lolex/ lolex.js usr/lib/nodejs/lolex/ +src usr/lib/nodejs/lolex/ diff -Nru node-lolex-1.5.1/debian/node_modules/bane/AUTHORS node-lolex-2.2.0/debian/node_modules/bane/AUTHORS --- node-lolex-1.5.1/debian/node_modules/bane/AUTHORS 1970-01-01 00:00:00.000000000 +0000 +++ node-lolex-2.2.0/debian/node_modules/bane/AUTHORS 2018-02-02 13:29:10.000000000 +0000 @@ -0,0 +1,3 @@ +Christian Johansen (christian@cjohansen.no) +August Lilleaas (august@augustl.com) +Stein Magnus Jodal (stein.magnus@jodal.no) \ No newline at end of file diff -Nru node-lolex-1.5.1/debian/node_modules/bane/autolint.js node-lolex-2.2.0/debian/node_modules/bane/autolint.js --- node-lolex-1.5.1/debian/node_modules/bane/autolint.js 1970-01-01 00:00:00.000000000 +0000 +++ node-lolex-2.2.0/debian/node_modules/bane/autolint.js 2018-02-02 13:29:10.000000000 +0000 @@ -0,0 +1,19 @@ +module.exports = { + paths: [ + "lib/*.js", + "test/*.js" + ], + linterOptions: { + node: true, + browser: true, + plusplus: true, + sloppy: true, + vars: true, + predef: [ + "define", + "assert", + "refute", + "buster" + ] + } +}; diff -Nru node-lolex-1.5.1/debian/node_modules/bane/buster.js node-lolex-2.2.0/debian/node_modules/bane/buster.js --- node-lolex-1.5.1/debian/node_modules/bane/buster.js 1970-01-01 00:00:00.000000000 +0000 +++ node-lolex-2.2.0/debian/node_modules/bane/buster.js 2018-02-02 13:29:10.000000000 +0000 @@ -0,0 +1,9 @@ +exports.Browsers = { + sources: ["lib/bane.js"], + tests: ["test/bane-test.js"] +}; + +exports.Node = { + extends: "Browsers", + environment: "node" +}; diff -Nru node-lolex-1.5.1/debian/node_modules/bane/lib/bane.js node-lolex-2.2.0/debian/node_modules/bane/lib/bane.js --- node-lolex-1.5.1/debian/node_modules/bane/lib/bane.js 1970-01-01 00:00:00.000000000 +0000 +++ node-lolex-2.2.0/debian/node_modules/bane/lib/bane.js 2018-02-02 13:29:10.000000000 +0000 @@ -0,0 +1,174 @@ +((typeof define === "function" && define.amd && function (m) { define("bane", m); }) || + (typeof module === "object" && function (m) { module.exports = m(); }) || + function (m) { this.bane = m(); } +)(function () { + "use strict"; + var slice = Array.prototype.slice; + + function handleError(event, error, errbacks) { + var i, l = errbacks.length; + if (l > 0) { + for (i = 0; i < l; ++i) { errbacks[i](event, error); } + return; + } + setTimeout(function () { + error.message = event + " listener threw error: " + error.message; + throw error; + }, 0); + } + + function assertFunction(fn) { + if (typeof fn !== "function") { + throw new TypeError("Listener is not function"); + } + return fn; + } + + function supervisors(object) { + if (!object.supervisors) { object.supervisors = []; } + return object.supervisors; + } + + function listeners(object, event) { + if (!object.listeners) { object.listeners = {}; } + if (event && !object.listeners[event]) { object.listeners[event] = []; } + return event ? object.listeners[event] : object.listeners; + } + + function errbacks(object) { + if (!object.errbacks) { object.errbacks = []; } + return object.errbacks; + } + + /** + * @signature var emitter = bane.createEmitter([object]); + * + * Create a new event emitter. If an object is passed, it will be modified + * by adding the event emitter methods (see below). + */ + function createEventEmitter(object) { + object = object || {}; + + function notifyListener(event, listener, args) { + try { + listener.listener.apply(listener.thisp || object, args); + } catch (e) { + handleError(event, e, errbacks(object)); + } + } + + object.on = function (event, listener, thisp) { + if (typeof event === "function") { + return supervisors(this).push({ + listener: event, + thisp: listener + }); + } + listeners(this, event).push({ + listener: assertFunction(listener), + thisp: thisp + }); + }; + + object.off = function (event, listener) { + var fns, events, i, l; + if (!event) { + fns = supervisors(this); + fns.splice(0, fns.length); + + events = listeners(this); + for (i in events) { + if (events.hasOwnProperty(i)) { + fns = listeners(this, i); + fns.splice(0, fns.length); + } + } + + fns = errbacks(this); + fns.splice(0, fns.length); + + return; + } + if (typeof event === "function") { + fns = supervisors(this); + listener = event; + } else { + fns = listeners(this, event); + } + if (!listener) { + fns.splice(0, fns.length); + return; + } + for (i = 0, l = fns.length; i < l; ++i) { + if (fns[i].listener === listener) { + fns.splice(i, 1); + return; + } + } + }; + + object.once = function (event, listener, thisp) { + var wrapper = function () { + object.off(event, wrapper); + listener.apply(this, arguments); + }; + + object.on(event, wrapper, thisp); + }; + + object.bind = function (object, events) { + var prop, i, l; + if (!events) { + for (prop in object) { + if (typeof object[prop] === "function") { + this.on(prop, object[prop], object); + } + } + } else { + for (i = 0, l = events.length; i < l; ++i) { + if (typeof object[events[i]] === "function") { + this.on(events[i], object[events[i]], object); + } else { + throw new Error("No such method " + events[i]); + } + } + } + return object; + }; + + object.emit = function (event) { + var toNotify = supervisors(this); + var args = slice.call(arguments), i, l; + + for (i = 0, l = toNotify.length; i < l; ++i) { + notifyListener(event, toNotify[i], args); + } + + toNotify = listeners(this, event).slice(); + args = slice.call(arguments, 1); + for (i = 0, l = toNotify.length; i < l; ++i) { + notifyListener(event, toNotify[i], args); + } + }; + + object.errback = function (listener) { + if (!this.errbacks) { this.errbacks = []; } + this.errbacks.push(assertFunction(listener)); + }; + + return object; + } + + return { + createEventEmitter: createEventEmitter, + aggregate: function (emitters) { + var aggregate = createEventEmitter(); + emitters.forEach(function (emitter) { + emitter.on(function (event, data) { + aggregate.emit(event, data); + }); + }); + return aggregate; + } + }; +}); diff -Nru node-lolex-1.5.1/debian/node_modules/bane/LICENSE node-lolex-2.2.0/debian/node_modules/bane/LICENSE --- node-lolex-1.5.1/debian/node_modules/bane/LICENSE 1970-01-01 00:00:00.000000000 +0000 +++ node-lolex-2.2.0/debian/node_modules/bane/LICENSE 2018-02-02 13:29:10.000000000 +0000 @@ -0,0 +1,25 @@ +(The BSD License) + +Copyright (c) 2010-2013, Christian Johansen, christian@cjohansen.no and +Stein Magnus Jodal, stein.magnus@jodal.no. All rights reserved. + +Redistribution and use in source and binary forms, with or without modification, +are permitted provided that the following conditions are met: + +1. Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + +2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND +ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR +ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON +ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. \ No newline at end of file diff -Nru node-lolex-1.5.1/debian/node_modules/bane/.npmignore node-lolex-2.2.0/debian/node_modules/bane/.npmignore --- node-lolex-1.5.1/debian/node_modules/bane/.npmignore 1970-01-01 00:00:00.000000000 +0000 +++ node-lolex-2.2.0/debian/node_modules/bane/.npmignore 2018-02-02 13:29:10.000000000 +0000 @@ -0,0 +1,3 @@ +*.log +node_modules +.idea diff -Nru node-lolex-1.5.1/debian/node_modules/bane/package.json node-lolex-2.2.0/debian/node_modules/bane/package.json --- node-lolex-1.5.1/debian/node_modules/bane/package.json 1970-01-01 00:00:00.000000000 +0000 +++ node-lolex-2.2.0/debian/node_modules/bane/package.json 2018-02-02 13:29:10.000000000 +0000 @@ -0,0 +1,37 @@ +{ + "name": "bane", + "version": "1.1.2", + "description": "(Yet another) Event emitter for Node, Browser globals and AMD", + "homepage": "http://busterjs.org/docs/bane/", + "author": "August Lilleaas and Christian Johansen", + "contributors": [ + { + "name": "Christian Johansen", + "email": "christian@cjohansen.no", + "url": "http://cjohansen.no" + }, + { + "name": "August Lilleaas", + "email": "august.lilleaas@gmail.com", + "url": "http://augustl.com" + }, + { + "name": "Stein Magnus Jodal", + "email": "stein.magnus@jodal.no", + "url": "http://jodal.no" + } + ], + "license": "BSD-2-Clause", + "main": "./lib/bane", + "repository": { + "type": "git", + "url": "https://github.com/busterjs/bane.git" + }, + "scripts": { + "test": "node node_modules/buster/bin/buster-test", + "test-debug": "node --debug-brk node_modules/buster/bin/buster-test" + }, + "devDependencies": { + "buster": "0.7.x" + } +} diff -Nru node-lolex-1.5.1/debian/node_modules/bane/Readme.md node-lolex-2.2.0/debian/node_modules/bane/Readme.md --- node-lolex-1.5.1/debian/node_modules/bane/Readme.md 1970-01-01 00:00:00.000000000 +0000 +++ node-lolex-2.2.0/debian/node_modules/bane/Readme.md 2018-02-02 13:29:10.000000000 +0000 @@ -0,0 +1,115 @@ +# BANE + +[![Build status](https://secure.travis-ci.org/busterjs/bane.png?branch=master)](http://travis-ci.org/busterjs/bane) + +> Browser globals, AMD and Node Events + +`bane` is a small event emitter library that works in browsers (including old +and rowdy ones, like IE6) and Node. It will define itself as an AMD module if +you want it to (i.e. if there's a `define` function available). + +`bane` is not entirely API compatible with Node's event emitter, but it does +provide the iconic `on` and `emit` functions. + +## Developers - Running tests + +``` +npm install +./node_modules/buster/bin/buster-test --node +./node_modules/buster/bin/buster-server +./node_modules/buster/bin/buster-test --browser +``` + +## Emitter creation API + +### `var emitter = bane.createEventEmitter([object]);` + + +Create a new event emitter. If an object is passed, it will be modified by +adding the event emitter methods (see below). + +## Emitter API + + +### `on(event, listener)` + +Register the `listener` function to be called when the emitter emits the +`event` (which is a string). + +### `on(listener)` + +Register the `listener` function as a "supervisor". It will be called for +any event emitted from the emitter. + +### `off(event, listener)` + +Remove a previously registered `listener` function for the specified `event` +(which is a string). If the function has not previously been registered, it is +silently ignored. + +### `off(listener)` + +Remove a previously registered "supervisor" `listener` function. If the +function has not previously been registered, it is silently ignored. + +###`off(event)` + +Remove all previously registered `listener` functions for the specified +`event` (which is a string). If no functions have previously been registered, +it is silently ignored. + +###`off()` + +Remove all previously registered listeners on the object, both regular +listeners, supervisor listeners, and errbacks. If no functions have previously +been registrered, it is silently ignored. + +###`once(event, listener)` + +Register a `listener` function for the given `event` (which is a string) +only once. After the first event has been emitted, the listener is removed. + +###`bind(object)` + +Register all methods on `object` as listeners for the event named as the +method name. Convenient way to bind many event listeners in one go: + +```javascript +var listener = { + start: function () { + console.log("Started!"); + }, + + end: function () { + console.log("Ended"); + } +}; + +emitter.bind(listener); +``` + +The above example will bind `listener.start` to the `"start"` event and vice +versa with `end`. Note that property names can be quoted to bind to any kind of +event name (e.g. `"test:start"`). + +### `bind(object, events)` + +Binds methods on `object` to corresponding events (see `bind(object)` +above), but instead of binding all methods on the object, only binds the +events listed in the provided `events` array. + +###`errback(listener)` + +Register the `listener` function as an "errback". It will be called with the +arguments `event` and `error` for any error thrown when listeners are +notified. + +### `emit(event[, data1[, data2[, ...]]])` + +Emit the `event` (which is a string) with optional data. Will cause all +registered listeners for the named event to be called. If additional arguments +are provided, the listeners will be called with them. + +## License + +Two-clause BSD-license, see [LICENSE](https://raw.github.com/busterjs/bane/master/LICENSE) diff -Nru node-lolex-1.5.1/debian/node_modules/bane/test/bane-test.js node-lolex-2.2.0/debian/node_modules/bane/test/bane-test.js --- node-lolex-1.5.1/debian/node_modules/bane/test/bane-test.js 1970-01-01 00:00:00.000000000 +0000 +++ node-lolex-2.2.0/debian/node_modules/bane/test/bane-test.js 2018-02-02 13:29:10.000000000 +0000 @@ -0,0 +1,446 @@ +if (typeof module === "object" && typeof require === "function") { + var buster = require("buster"); + var bane = require("../lib/bane"); +} + +var assert = buster.assert; +var refute = buster.refute; + +buster.testCase("bane", { + ".create": { + "returns event emitter": function () { + var emitter = bane.createEventEmitter(); + + assert.isObject(emitter); + assert.isFunction(emitter.on); + assert.isFunction(emitter.emit); + }, + + "returns and extends existing object": function () { + var object = {}; + var emitter = bane.createEventEmitter(object); + + assert.same(object, emitter); + assert.isFunction(emitter.on); + assert.isFunction(emitter.emit); + } + }, + + ".on": { + "throws for uncallable listener": function () { + var emitter = bane.createEventEmitter(); + + assert.exception(function () { + emitter.on("event", {}); + }); + }, + + "supervisor is notified of all events": function () { + var supervisor = this.spy(); + var emitter = bane.createEventEmitter(); + + emitter.on(supervisor); + emitter.emit("something", 42); + emitter.emit("stuff", { id: 13 }); + + assert.calledTwice(supervisor); + assert.calledWith(supervisor, "something", 42); + } + }, + + ".errback": { + "fails when passing non-function": function () { + var emitter = bane.createEventEmitter(); + assert.exception(function () { + emitter.errback({}); + }); + } + }, + + ".emit": { + "calls all listeners": function () { + var emitter = bane.createEventEmitter(); + var listeners = [this.spy(), this.spy()]; + emitter.on("event", listeners[0]); + emitter.on("event", listeners[1]); + + emitter.emit("event"); + + assert.called(listeners[0]); + assert.called(listeners[1]); + }, + + "calls all listeners with correct this object": function () { + var emitter = bane.createEventEmitter(); + var listeners = [this.spy(), this.spy()]; + var obj = {}; + emitter.on("event", listeners[0], obj); + emitter.on("event", listeners[1]); + + emitter.emit("event"); + + assert.calledOn(listeners[0], obj); + assert.calledOn(listeners[1], emitter); + }, + + "passes through arguments": function () { + var emitter = bane.createEventEmitter(); + var listener = this.spy(); + + emitter.on("event", listener); + emitter.emit("event", "String", 1, 32); + + assert.calledWith(listener, "String", 1, 32); + }, + + "emits all even when some fail": function () { + var emitter = bane.createEventEmitter(); + var listeners = [ + this.stub().throws("I'm thrown on purpose"), + this.spy() + ]; + + emitter.on("event", listeners[0]); + emitter.on("event", listeners[1]); + + emitter.emit("event"); + + assert.called(listeners[1]); + }, + + "passes error to errback": function () { + var emitter = bane.createEventEmitter(); + var errback = this.spy(); + emitter.errback(errback); + + emitter.on("event", this.stub().throws()); + emitter.emit("event"); + + assert.calledOnce(errback); + }, + + "calls listeners in the order they were added": function () { + var emitter = bane.createEventEmitter(); + var listeners = [this.spy(), this.spy()]; + + emitter.on("event", listeners[0]); + emitter.on("event", listeners[1]); + + emitter.emit("event"); + + assert.callOrder(listeners[0], listeners[1]); + }, + + "calls supervisors before other listeners": function () { + var emitter = bane.createEventEmitter(); + var supervisors = [this.spy(), this.spy()]; + var listeners = [this.spy(), this.spy()]; + + emitter.on("event", listeners[0]); + emitter.on("event", listeners[1]); + emitter.on(supervisors[0]); + emitter.on(supervisors[1]); + + emitter.emit("event"); + + assert.callOrder( + supervisors[0], supervisors[1], listeners[0], listeners[1]); + }, + + "does not fail if no listeners": function () { + var emitter = bane.createEventEmitter(); + + refute.exception(function () { + emitter.emit("event"); + }); + }, + + "only notifies relevant listeners": function () { + var emitter = bane.createEventEmitter(); + var listeners = [this.spy(), this.spy()]; + + emitter.on("event", listeners[0]); + emitter.on("other", listeners[1]); + + emitter.emit("other"); + + assert.called(listeners[1]); + refute.called(listeners[0]); + }, + + // AKA "creates extensible emitters" + "does not emit events to other emitter's listeners": function () { + function Thing() {} + Thing.prototype = bane.createEventEmitter(); + var emitter1 = new Thing(); + var emitter2 = new Thing(); + var listener = this.spy(); + emitter1.on("ouch", listener); + + emitter2.emit("ouch"); + + refute.called(listener); + } + }, + + ".bind": { + "returns object bound to": function () { + var listener = { doIt: function () {} }; + var result = bane.createEventEmitter().bind(listener, ["doIt"]); + + assert.same(result, listener); + }, + + "binds to method named after event": function () { + var emitter = bane.createEventEmitter(); + var listener = { doIt: this.spy() }; + + emitter.bind(listener); + emitter.emit("doIt", 42); + + assert.calledOnceWith(listener.doIt, 42); + assert.calledOn(listener.doIt, listener); + }, + + "binds all methods as listeners to corresponding events": function () { + var emitter = bane.createEventEmitter(); + var listener = { + complete: this.spy(), + failure: this.spy(), + success: this.spy() + }; + + emitter.bind(listener); + emitter.emit("complete"); + emitter.emit("failure"); + emitter.emit("success"); + + assert.calledOnce(listener.complete); + assert.calledOnce(listener.failure); + assert.calledOnce(listener.success); + }, + + "binds inherited methods": function () { + var emitter = bane.createEventEmitter(); + function F() {} + F.prototype = { something: this.spy() }; + var listener = new F(); + listener.failure = function () {}; + + emitter.bind(listener); + emitter.emit("something"); + + assert.calledOnce(F.prototype.something); + }, + + "binds array of methods/events": function () { + var emitter = bane.createEventEmitter(); + var listener = { + one: this.spy(), + two: this.spy(), + three: this.spy() + }; + + emitter.bind(listener, ["one", "three"]); + emitter.emit("one"); + emitter.emit("two"); + emitter.emit("three"); + + assert.called(listener.one); + assert.calledOn(listener.one, listener); + refute.called(listener.two); + assert.called(listener.three); + }, + + "fails array when binding non-existent method": function () { + var emitter = bane.createEventEmitter(); + var listener = {}; + + assert.exception(function () { + emitter.bind(listener, ["one"]); + }); + } + }, + + ".off": { + "removes listener": function () { + var listener = this.spy(); + var emitter = bane.createEventEmitter(); + + emitter.on("event", listener); + emitter.off("event", listener); + emitter.emit("event"); + + refute.called(listener); + }, + + "removes supervisor listener": function () { + var supervisor = this.spy(); + var emitter = bane.createEventEmitter(); + + emitter.on(supervisor); + emitter.off(supervisor); + emitter.emit("something", 42); + emitter.emit("stuff", { id: 13 }); + + refute.called(supervisor); + }, + + "should not remove listener for other event": function () { + var listener = this.spy(); + var emitter = bane.createEventEmitter(); + + emitter.on("event", listener); + emitter.off("event2", listener); + emitter.emit("event"); + emitter.emit("event2"); + + assert.calledOnce(listener); + }, + + "should not remove other listeners": function () { + var listeners = [this.spy(), this.spy(), this.spy()]; + var emitter = bane.createEventEmitter(); + + emitter.on("event", listeners[0]); + emitter.on("event", listeners[1]); + emitter.on("event", listeners[2]); + emitter.off("event", listeners[1]); + emitter.emit("event"); + + assert.calledOnce(listeners[0]); + refute.called(listeners[1]); + assert.calledOnce(listeners[2]); + }, + + "without listener should remove all listeners": function () { + var listeners = [this.spy(), this.spy(), this.spy()]; + var emitter = bane.createEventEmitter(); + + emitter.on("event", listeners[0]); + emitter.on("event", listeners[1]); + emitter.on("event", listeners[2]); + emitter.off("event"); + emitter.emit("event"); + + refute.called(listeners[0]); + refute.called(listeners[1]); + refute.called(listeners[2]); + }, + + "without any args removes all supervisors": function () { + var supervisors = [this.spy(), this.spy()]; + var emitter = bane.createEventEmitter(); + + emitter.on(supervisors[0]); + emitter.on(supervisors[1]); + emitter.off(); + emitter.emit("event1"); + emitter.emit("event2"); + + refute.called(supervisors[0]); + refute.called(supervisors[1]); + }, + + "without any args removes all listeners": function () { + var listeners = [this.spy(), this.spy()]; + var emitter = bane.createEventEmitter(); + + emitter.on("event1", listeners[0]); + emitter.on("event2", listeners[1]); + emitter.off(); + emitter.emit("event1"); + emitter.emit("event2"); + + refute.called(listeners[0]); + refute.called(listeners[1]); + }, + + "without any args removes all errbacks": function() { + var emitter = bane.createEventEmitter(); + var errback = this.spy(); + emitter.errback(errback); + + emitter.on("event", this.stub().throws()); + emitter.off(); + emitter.emit("event"); + + refute.called(errback); + }, + + "should remove listener in other listener for same event": function () { + var emitter = bane.createEventEmitter(); + var listener = this.spy(); + + emitter.on("foo", function () { + emitter.off("foo", listener); + }); + emitter.on("foo", listener); + emitter.emit("foo"); + emitter.emit("foo"); + + assert.calledOnce(listener); + } + }, + + ".once": { + "is only called once": function () { + var listener = this.spy(); + var emitter = bane.createEventEmitter(); + + emitter.once("event", listener); + emitter.emit("event"); + emitter.emit("event"); + + assert.calledOnce(listener); + }, + + "is called with emitted arguments": function () { + var listener = this.spy(); + var emitter = bane.createEventEmitter(); + + emitter.once("event", listener); + emitter.emit("event", "foo", 1); + + assert.calledWithExactly(listener, "foo", 1); + }, + + "is called with context": function () { + var emitter = bane.createEventEmitter(); + var listener = function () { this.foo = "bar"; }; + var obj = {}; + + emitter.on("event", listener, obj); + emitter.emit("event"); + + assert.equals("bar", obj.foo); + } + }, + + ".aggregate": { + "proxies events": function () { + var emitter = bane.createEventEmitter(); + var listener = this.spy(); + + var aggregated = bane.aggregate([emitter]); + aggregated.on("something", listener); + emitter.emit("something"); + + assert.calledOnce(listener); + }, + + "proxies multiple event emitters": function () { + var emitter1 = bane.createEventEmitter(); + var emitter2 = bane.createEventEmitter(); + var listener = this.spy(); + + var aggregated = bane.aggregate([emitter1, emitter2]); + aggregated.on("some-other-thing", listener); + + emitter1.emit("some-other-thing"); + emitter2.emit("some-other-thing"); + + assert.calledTwice(listener); + } + } +}); diff -Nru node-lolex-1.5.1/debian/node_modules/bane/.travis.yml node-lolex-2.2.0/debian/node_modules/bane/.travis.yml --- node-lolex-1.5.1/debian/node_modules/bane/.travis.yml 1970-01-01 00:00:00.000000000 +0000 +++ node-lolex-2.2.0/debian/node_modules/bane/.travis.yml 2018-02-02 13:29:10.000000000 +0000 @@ -0,0 +1,9 @@ +language: node_js +sudo: false +node_js: + - "0.10" + - "0.12" + - "4" + - "5" +before_install: + - npm i -g npm diff -Nru node-lolex-1.5.1/debian/node_modules/referee/AUTHORS node-lolex-2.2.0/debian/node_modules/referee/AUTHORS --- node-lolex-1.5.1/debian/node_modules/referee/AUTHORS 1970-01-01 00:00:00.000000000 +0000 +++ node-lolex-2.2.0/debian/node_modules/referee/AUTHORS 2018-02-02 13:28:15.000000000 +0000 @@ -0,0 +1,6 @@ +Christian Johansen, christian@cjohansen.no +August Lilleaas, august.lilleaas@gmail.com +Dave Geddes davidcgeddes@gmail.com +Malcolm Locke malc@wholemeal.co.nz +Stein Magnus Jodal stein.magnus@jodal.no +Balazs Ree ree@greenfinity.hu diff -Nru node-lolex-1.5.1/debian/node_modules/referee/autolint.js node-lolex-2.2.0/debian/node_modules/referee/autolint.js --- node-lolex-1.5.1/debian/node_modules/referee/autolint.js 1970-01-01 00:00:00.000000000 +0000 +++ node-lolex-2.2.0/debian/node_modules/referee/autolint.js 2018-02-02 13:28:15.000000000 +0000 @@ -0,0 +1,22 @@ +module.exports = { + linter: "jshint", + paths: [ + "lib/**/*.js", + "test/**/*.js" + ], + linterOptions: { + node: true, + browser: true, + plusplus: false, + strict: false, + onevar: false, + nomen: false, + regexp: true, + predef: [ + "define", + "assert", + "refute", + "buster" + ] + } +}; diff -Nru node-lolex-1.5.1/debian/node_modules/referee/buster.js node-lolex-2.2.0/debian/node_modules/referee/buster.js --- node-lolex-1.5.1/debian/node_modules/referee/buster.js 1970-01-01 00:00:00.000000000 +0000 +++ node-lolex-2.2.0/debian/node_modules/referee/buster.js 2018-02-02 13:28:15.000000000 +0000 @@ -0,0 +1,26 @@ +exports["browser"] = { + environment: "browser", + libs: [ + "node_modules/when/es6-shim/Promise.js", + "node_modules/lodash/index.js", + "node_modules/samsam/lib/samsam.js", + "node_modules/bane/lib/bane.js" + ], + sources: [ + "lib/expect.js", + "lib/referee.js" + ], + testHelpers: ["test/test-helper.js"], + tests: ["test/*-test.js"] +}; + +exports["node"] = { + environment: "node", + testHelpers: [ + "node_modules/when/es6-shim/Promise.js", + "test/test-helper.js" + ], + tests: [ + "test/*-test.js" + ] +}; diff -Nru node-lolex-1.5.1/debian/node_modules/referee/Gruntfile.js node-lolex-2.2.0/debian/node_modules/referee/Gruntfile.js --- node-lolex-1.5.1/debian/node_modules/referee/Gruntfile.js 1970-01-01 00:00:00.000000000 +0000 +++ node-lolex-2.2.0/debian/node_modules/referee/Gruntfile.js 2018-02-02 13:28:15.000000000 +0000 @@ -0,0 +1,24 @@ +module.exports = function (grunt) { + + grunt.loadNpmTasks("grunt-buster"); + + grunt.initConfig({ + "buster": { + "browser": { + "test": { + "config-group": "browser" + } + }, + "node": { + "test": { + "config-group": "node" + } + } + } + }); + + grunt.registerTask("test", "Clean build, minify and run tests", + ["buster:node:test", "buster:browser:server", "buster:browser:phantomjs", "buster:browser:test"] + ); + +}; diff -Nru node-lolex-1.5.1/debian/node_modules/referee/lib/expect.js node-lolex-2.2.0/debian/node_modules/referee/lib/expect.js --- node-lolex-1.5.1/debian/node_modules/referee/lib/expect.js 1970-01-01 00:00:00.000000000 +0000 +++ node-lolex-2.2.0/debian/node_modules/referee/lib/expect.js 2018-02-02 13:28:15.000000000 +0000 @@ -0,0 +1,67 @@ +((typeof define === "function" && define.amd && function (m) { + define("expect", ["lodash"], m); +}) || (typeof module === "object" && function (m) { + module.exports = m(require("lodash")); +}) || function (m) { this.expect = m(this._); } +)(function (_) { + var expectation = {}; + function F() {} + var create = function (object) { F.prototype = object; return new F(); }; + + var expect = function (actual) { + var expectation = _.extend(create(expect.expectation), { + actual: actual, + assertMode: true + }); + expectation.not = create(expectation); + expectation.not.assertMode = false; + return expectation; + }; + + expect.expectation = expectation; + + expect.wrapAssertion = function (assertion, expectation, referee) { + expect.expectation[expectation] = function () { + var args = [this.actual].concat(_.toArray(arguments)); + var type = this.assertMode ? "assert" : "refute"; + var callFunc; + + if (assertion === "assert") { + callFunc = this.assertMode ? referee.assert : referee.refute; + } else if (assertion === "refute") { + callFunc = this.assertMode ? referee.refute : referee.assert; + } else { + callFunc = referee[type][assertion]; + } + + try { + return callFunc.apply(referee.expect, args); + } catch (e) { + e.message = (e.message || "").replace( + "[" + type + "." + assertion + "]", + "[expect." + (this.assertMode ? "" : "not.") + + expectation + "]" + ); + throw e; + } + }; + }; + + expect.init = function (referee) { + _.each(_.keys(referee.assert), function (name) { + var expectationName = referee.assert[name].expectationName; + if (expectationName) { + expect.wrapAssertion(name, expectationName, referee); + } + }); + + expect.wrapAssertion("assert", "toBeTruthy", referee); + expect.wrapAssertion("refute", "toBeFalsy", referee); + + if (expect.expectation.toBeNear) { + expect.expectation.toBeCloseTo = expect.expectation.toBeNear; + } + }; + + return expect; +}); diff -Nru node-lolex-1.5.1/debian/node_modules/referee/lib/referee.js node-lolex-2.2.0/debian/node_modules/referee/lib/referee.js --- node-lolex-1.5.1/debian/node_modules/referee/lib/referee.js 1970-01-01 00:00:00.000000000 +0000 +++ node-lolex-2.2.0/debian/node_modules/referee/lib/referee.js 2018-02-02 13:28:15.000000000 +0000 @@ -0,0 +1,716 @@ +((typeof define === "function" && define.amd && function (m) { + define("referee", ["expect", "lodash", "samsam", "bane"], m); +}) || (typeof module === "object" && function (m) { + module.exports = m( + require("./expect"), + require("lodash"), + require("samsam"), + require("bane") + ); +}) || function (m) { + this.referee = m( + this.expect, + this._, + this.samsam, + this.bane + ); +})(function (expect, _, samsam, bane) { + "use strict"; + + var toString = Object.prototype.toString; + var slice = Array.prototype.slice; + var assert, refute, referee = bane.createEventEmitter(); + + referee.countAssertion = function countAssertion() { + if (typeof referee.count !== "number") { referee.count = 0; } + referee.count += 1; + }; + + function interpolate(string, prop, value) { + return string.replace(new RegExp("\\$\\{" + prop + "\\}", "g"), value); + } + + // Interpolate positional arguments. Replaces occurences of ${} in + // the string with the corresponding entry in values[] + function interpolatePosArg(message, values) { + return _.reduce(values, function (msg, value, index) { + return interpolate(msg, index, referee.format(value)); + }, message); + } + + function interpolateProperties(message, properties) { + return _.reduce(_.keys(properties), function (str, name) { + var formattedValue = name === "customMessage" ? referee.prepareMessage(properties[name]) : referee.format(properties[name]); + return interpolate(str, name, formattedValue); + }, message || ""); + } + + // Internal helper. Used throughout to fail assertions if they receive + // too few arguments. The name is provided for a helpful error message. + function assertArgNum(name, args, num, fail) { + fail = fail || referee.fail; + if (args.length < num) { + fail("[" + name + "] Expected to receive at least " + + num + " argument" + (num > 1 ? "s" : "")); + return false; + } + return true; + } + + function createAssertion(type, name, func, minArgs, messageValues, pass, fail) { + + var assertion = function () { + + var fullName = type + "." + name, failed = false; + + if (!assertArgNum(fullName, arguments, minArgs || func.length, fail)) { + return; + } + + var args = slice.call(arguments, 0), + namedValues = {}; + + if (typeof messageValues === "function") { + var replacedValues = messageValues.apply(this, args); + if (typeof(replacedValues) === "object") { + namedValues = replacedValues; + } else { + args = replacedValues; + } + } + + var ctx = { + fail: function (msg) { + failed = true; + delete this.fail; + var message = referee[type][name][msg] || msg; + message = interpolatePosArg(message, args); + message = interpolateProperties(message, this); + message = interpolateProperties(message, namedValues); + fail("[" + type + "." + name + "] " + message); + return false; + } + }; + + if (!func.apply(ctx, arguments) && !failed) { + // when a function returns false and hasn't already failed with a custom message, + // fail with default message + ctx.fail("message"); + } + + if (!failed) { + pass(["pass", fullName].concat(args)); + } + }; + + return assertion; + } + + // Internal helper. Not the most elegant of functions, but it takes + // care of all the nitty-gritty of assertion functions: counting, + // verifying parameter count, interpolating messages with actual + // values and so on. + function defineAssertion(type, name, func, minArgs, messageValues) { + + referee[type][name] = function () { + referee.countAssertion(); + var assertion = createAssertion(type, name, func, minArgs, messageValues, referee.pass, referee.fail); + assertion.apply(null, arguments); + }; + referee[type][name].test = function () { + var args = arguments; + return new Promise(function (resolve, reject) { + var assertion = createAssertion(type, name, func, minArgs, messageValues, resolve, reject); + assertion.apply(null, args); + }); + }; + } + + referee.add = function (name, opt) { + var refuteArgs; + + if (opt.refute) { + refuteArgs = opt.refute.length; + } else { + refuteArgs = opt.assert.length; + opt.refute = function () { + return !opt.assert.apply(this, arguments); + }; + } + + var values = opt.values; + defineAssertion("assert", name, opt.assert, opt.assert.length, values); + defineAssertion("refute", name, opt.refute, refuteArgs, values); + + assert[name].message = opt.assertMessage; + refute[name].message = opt.refuteMessage; + + if (opt.expectation) { + if (referee.expect && referee.expect.wrapAssertion) { + referee.expect.wrapAssertion(name, opt.expectation, referee); + } else { + assert[name].expectationName = opt.expectation; + refute[name].expectationName = opt.expectation; + } + } + }; + + assert = referee.assert = function assert(actual, message) { + referee.countAssertion(); + if (!assertArgNum("assert", arguments, 1)) { return; } + + if (!actual) { + var v = referee.format(actual); + referee.fail(message || "[assert] Expected " + v + " to be truthy"); + } else { + referee.emit("pass", "assert", message || "", actual); + } + }; + + assert.toString = function () { + return "referee.assert()"; + }; + + refute = referee.refute = function (actual, message) { + referee.countAssertion(); + if (!assertArgNum("refute", arguments, 1)) { return; } + + if (actual) { + var v = referee.format(actual); + referee.fail(message || "[refute] Expected " + v + " to be falsy"); + } else { + referee.emit("pass", "refute", message || "", actual); + } + }; + + referee.count = 0; + + referee.pass = function (message) { + referee.emit.apply(referee, message); + } + + referee.fail = function (message) { + var exception = new Error(message); + exception.name = "AssertionError"; + + try { + throw exception; + } catch (e) { + referee.emit("failure", e); + } + + if (typeof referee.throwOnFailure !== "boolean" || + referee.throwOnFailure) { + throw exception; + } + }; + + referee.format = function (object) { return String(object); }; + + referee.prepareMessage = function msg(message) { + if (!message) { + return ""; + } + return message + (/[.:!?]$/.test(message) ? " " : ": "); + }; + + function actualAndExpectedMessageValues(actual, expected, message) { + return { + actual: actual, + expected: expected, + customMessage: message + }; + } + + function actualMessageValues(actual, message) { + return { + actual: actual, + customMessage: message + }; + } + + function actualAndTypeOfMessageValues(actual, message) { + return { + actual: actual, + actualType: typeof actual, + customMessage: message + }; + } + + referee.add("same", { + assert: function (actual, expected) { + return samsam.identical(actual, expected); + }, + refute: function (actual, expected) { + return !samsam.identical(actual, expected); + }, + assertMessage: "${customMessage}${actual} expected to be the same object as ${expected}", + refuteMessage: "${customMessage}${actual} expected not to be the same object as ${expected}", + expectation: "toBe", + values: actualAndExpectedMessageValues + }); + + // Extract/replace with separate module that does a more detailed + // visualization of multi-line strings + function multiLineStringDiff(actual, expected, message) { + if (actual === expected) { return true; } + + var heading = assert.equals.multiLineStringHeading; + var failureText = interpolateProperties(heading, { customMessage: message }); + var actualLines = actual.split("\n"); + var expectedLines = expected.split("\n"); + var lineCount = Math.max(expectedLines.length, actualLines.length); + var i, lines = []; + + for (i = 0; i < lineCount; ++i) { + if (expectedLines[i] !== actualLines[i]) { + lines.push("line " + (i + 1) + ": " + (expectedLines[i] || "") + + "\nwas: " + (actualLines[i] || "")); + } + } + + referee.fail("[assert.equals] " + failureText + lines.join("\n\n")); + return false; + } + + referee.add("equals", { + // Uses arguments[2] because the function's .length is used to determine + // the minimum required number of arguments. + assert: function (actual, expected) { + if (typeof actual === "string" && typeof expected === "string" && + (actual.indexOf("\n") >= 0 || + expected.indexOf("\n") >= 0)) { + return multiLineStringDiff(actual, expected, arguments[2]); + } + + return samsam.deepEqual(actual, expected); + }, + + refute: function (actual, expected) { + return !samsam.deepEqual(actual, expected); + }, + + assertMessage: "${customMessage}${actual} expected to be equal to ${expected}", + refuteMessage: "${customMessage}${actual} expected not to be equal to ${expected}", + expectation: "toEqual", + values: actualAndExpectedMessageValues + }); + + assert.equals.multiLineStringHeading = "${customMessage}Expected multi-line strings " + + "to be equal:\n"; + + referee.add("greater", { + assert: function (actual, expected) { + return actual > expected; + }, + + assertMessage: "${customMessage}Expected ${actual} to be greater than ${expected}", + refuteMessage: "${customMessage}Expected ${actual} to be less than or equal to ${expected}", + expectation: "toBeGreaterThan", + values: actualAndExpectedMessageValues + }); + + referee.add("less", { + assert: function (actual, expected) { + return actual < expected; + }, + + assertMessage: "${customMessage}Expected ${actual} to be less than ${expected}", + refuteMessage: "${customMessage}Expected ${actual} to be greater than or equal to ${expected}", + expectation: "toBeLessThan", + values: actualAndExpectedMessageValues + }); + + referee.add("defined", { + assert: function (actual) { + return typeof actual !== "undefined"; + }, + assertMessage: "${customMessage}Expected to be defined", + refuteMessage: "${customMessage}Expected ${actual} (${actualType}) not to be defined", + expectation: "toBeDefined", + values: actualAndTypeOfMessageValues + }); + + referee.add("isNull", { + assert: function (actual) { + return actual === null; + }, + assertMessage: "${customMessage}Expected ${actual} to be null", + refuteMessage: "${customMessage}Expected not to be null", + expectation: "toBeNull", + values: actualMessageValues + }); + + + referee.match = function (actual, matcher) { + try { + return samsam.match(actual, matcher); + } catch (e) { + throw new Error("Matcher (" + referee.format(matcher) + + ") was not a string, a number, a function, " + + "a boolean or an object"); + } + }; + + referee.add("match", { + assert: function (actual, matcher) { + var passed; + + try { + passed = referee.match(actual, matcher); + } catch (e) { + this.exceptionMessage = e.message; + return this.fail("exceptionMessage"); + } + + return passed; + }, + + refute: function (actual, matcher) { + var passed; + + try { + passed = referee.match(actual, matcher); + } catch (e) { + this.exceptionMessage = e.message; + return this.fail("exceptionMessage"); + } + + return !passed; + }, + + assertMessage: "${customMessage}${actual} expected to match ${expected}", + refuteMessage: "${customMessage}${actual} expected not to match ${expected}", + expectation: "toMatch", + values: actualAndExpectedMessageValues + }); + + assert.match.exceptionMessage = refute.match.exceptionMessage = "${customMessage}${exceptionMessage}"; + + referee.add("isObject", { + assert: function (actual) { + return typeof actual === "object" && !!actual; + }, + assertMessage: "${customMessage}${actual} (${actualType}) expected to be object and not null", + refuteMessage: "${customMessage}${actual} expected to be null or not an object", + expectation: "toBeObject", + values: actualAndTypeOfMessageValues + }); + + referee.add("isFunction", { + assert: function (actual) { + return typeof actual === "function"; + }, + assertMessage: "${customMessage}${actual} (${actualType}) expected to be function", + refuteMessage: "${customMessage}${actual} expected not to be function", + expectation: "toBeFunction", + values: function (actual, message) { + return { + actual: String(actual).replace("\n", ""), + actualType: typeof actual, + customMessage: message + }; + } + }); + + referee.add("isTrue", { + assert: function (actual) { + return actual === true; + }, + assertMessage: "${customMessage}Expected ${actual} to be true", + refuteMessage: "${customMessage}Expected ${actual} to not be true", + expectation: "toBeTrue", + values: actualMessageValues + }); + + referee.add("isFalse", { + assert: function (actual) { + return actual === false; + }, + assertMessage: "${customMessage}Expected ${actual} to be false", + refuteMessage: "${customMessage}Expected ${actual} to not be false", + expectation: "toBeFalse", + values: actualMessageValues + }); + + referee.add("isString", { + assert: function (actual) { + return typeof actual === "string"; + }, + assertMessage: "${customMessage}Expected ${actual} (${actualType}) to be string", + refuteMessage: "${customMessage}Expected ${actual} not to be string", + expectation: "toBeString", + values: actualAndTypeOfMessageValues + }); + + referee.add("isBoolean", { + assert: function (actual) { + return typeof actual === "boolean"; + }, + assertMessage: "${customMessage}Expected ${actual} (${actualType}) to be boolean", + refuteMessage: "${customMessage}Expected ${actual} not to be boolean", + expectation: "toBeBoolean", + values: actualAndTypeOfMessageValues + }); + + referee.add("isNumber", { + assert: function (actual) { + return typeof actual === "number" && !isNaN(actual); + }, + assertMessage: "${customMessage}Expected ${actual} (${actualType}) to be a non-NaN number", + refuteMessage: "${customMessage}Expected ${actual} to be NaN or a non-number value", + expectation: "toBeNumber", + values: actualAndTypeOfMessageValues + }); + + referee.add("isNaN", { + assert: function (actual) { + return typeof actual === "number" && isNaN(actual); + }, + assertMessage: "${customMessage}Expected ${actual} to be NaN", + refuteMessage: "${customMessage}Expected not to be NaN", + expectation: "toBeNaN", + values: actualAndTypeOfMessageValues + }); + + referee.add("isArray", { + assert: function (actual) { + return toString.call(actual) === "[object Array]"; + }, + assertMessage: "${customMessage}Expected ${actual} to be array", + refuteMessage: "${customMessage}Expected ${actual} not to be array", + expectation: "toBeArray", + values: actualAndTypeOfMessageValues + }); + + function isArrayLike(object) { + return _.isArray(object) || + (!!object && typeof object.length === "number" && + typeof object.splice === "function") || + _.isArguments(object); + } + + referee.isArrayLike = isArrayLike; + + referee.add("isArrayLike", { + assert: function (actual) { + return isArrayLike(actual); + }, + assertMessage: "${customMessage}Expected ${actual} to be array like", + refuteMessage: "${customMessage}Expected ${actual} not to be array like", + expectation: "toBeArrayLike", + values: actualAndTypeOfMessageValues + }); + + function exactKeys(object, keys) { + var keyMap = {}; + var keyCnt = 0; + for (var i = 0; i < keys.length; i++) { + keyMap[keys[i]] = true; + keyCnt += 1; + } + for (var key in object) { + if (object.hasOwnProperty(key)) { + if (! keyMap[key]) { + return false; + } + keyCnt -= 1; + } + } + return keyCnt === 0; + } + + referee.add("keys", { + assert: function (actual, keys) { + return exactKeys(actual, keys); + }, + assertMessage: "${customMessage}Expected ${actualObject} to have exact keys ${keys}", + refuteMessage: "${customMessage}Expected not to have exact keys ${keys}", + expectation: "toHaveKeys", + values: function (actual, keys, message) { + return { + actualObject: actual, + keys: keys, + customMessage: message + } + } + }); + + function captureException(callback) { + try { callback(); } catch (e) { return e; } + return null; + } + + referee.captureException = captureException; + + referee.add("exception", { + assert: function (callback) { + var matcher = arguments[1]; + var customMessage = arguments[2]; + + if (typeof matcher === "string") { + customMessage = matcher; + matcher = undefined; + } + + this.expected = matcher; + this.customMessage = customMessage; + + var err = captureException(callback); + + if (err) { + this.actualExceptionType = err.name; + this.actualExceptionMessage = err.message; + this.actualExceptionStack = err.stack; + } + + if (!err) { + if (typeof matcher === "object") { + return this.fail("typeNoExceptionMessage"); + } else { + return this.fail("message"); + } + } + + if (typeof matcher === "object" && !referee.match(err, matcher)) { + return this.fail("typeFailMessage"); + } + + if (typeof matcher === "function" && matcher(err) !== true) { + return this.fail("matchFailMessage"); + } + + return true; + }, + + refute: function (callback) { + var err = captureException(callback); + + if (err) { + this.customMessage = arguments[1]; + this.actualExceptionType = err.name; + this.actualExceptionMessage = err.message; + return false; + } + + return true; + }, + + expectation: "toThrow", + assertMessage: "${customMessage}Expected exception", + refuteMessage: "${customMessage}Expected not to throw but threw ${actualExceptionType} (${actualExceptionMessage})" + }); + + assert.exception.typeNoExceptionMessage = "${customMessage}Expected ${expected} but no exception was thrown"; + assert.exception.typeFailMessage = "${customMessage}Expected ${expected} but threw ${actualExceptionType} (${actualExceptionMessage})\n${actualExceptionStack}"; + assert.exception.matchFailMessage = "${customMessage}Expected thrown ${actualExceptionType} (${actualExceptionMessage}) to pass matcher function"; + + + referee.add("near", { + assert: function (actual, expected, delta) { + return Math.abs(actual - expected) <= delta; + }, + assertMessage: "${customMessage}Expected ${actual} to be equal to ${expected} +/- ${delta}", + refuteMessage: "${customMessage}Expected ${actual} not to be equal to ${expected} +/- ${delta}", + expectation: "toBeNear", + values: function (actual, expected, delta, message) { + return { + actual: actual, + expected: expected, + delta: delta, + customMessage: message + }; + } + }); + + referee.add("hasPrototype", { + assert: function (actual, protoObj) { + return protoObj.isPrototypeOf(actual); + }, + assertMessage: "${customMessage}Expected ${actual} to have ${expected} on its prototype chain", + refuteMessage: "${customMessage}Expected ${actual} not to have ${expected} on its " + + "prototype chain", + expectation: "toHavePrototype", + values: actualAndExpectedMessageValues + }); + + referee.add("contains", { + assert: function (haystack, needle) { + return _.include(haystack, needle); + }, + assertMessage: "${customMessage}Expected [${actual}] to contain ${expected}", + refuteMessage: "${customMessage}Expected [${actual}] not to contain ${expected}", + expectation: "toContain", + values: actualAndExpectedMessageValues + }); + + referee.add("tagName", { + assert: function (element, tagName) { + // Uses arguments[2] because the function's .length is used to + // determine the minimum required number of arguments. + if (!element.tagName) { + return this.fail("noTagNameMessage"); + } + + return tagName.toLowerCase && + tagName.toLowerCase() === element.tagName.toLowerCase(); + }, + assertMessage: "${customMessage}Expected tagName to be ${expected} but was ${actual}", + refuteMessage: "${customMessage}Expected tagName not to be ${actual}", + expectation: "toHaveTagName", + values: function (element, tagName, message) { + return { + actualElement: element, + actual: element.tagName, + expected: tagName, + customMessage: message + }; + } + }); + + assert.tagName.noTagNameMessage = "${customMessage}Expected ${actualElement} to have tagName " + + "property"; + refute.tagName.noTagNameMessage = "${customMessage}Expected ${actualElement} to have tagName " + + "property"; + + referee.add("className", { + assert: function (element, name) { + if (typeof element.className === "undefined") { + return this.fail("noClassNameMessage"); + } + + var expected = typeof name === "string" ? name.split(" ") : name; + var actual = element.className.split(" "); + var i, l; + for (i = 0, l = expected.length; i < l; i++) { + if (!_.include(actual, expected[i])) { return false; } + } + + return true; + }, + assertMessage: "${customMessage}Expected object's className to include ${expected} " + + "but was ${actual}", + refuteMessage: "${customMessage}Expected object's className not to include ${expected}", + expectation: "toHaveClassName", + values: function (element, className, message) { + return { + actualElement: element, + actual: element.className, + expected: className, + customMessage: message + }; + } + }); + + assert.className.noClassNameMessage = "${customMessage}Expected object to have " + + "className property"; + refute.className.noClassNameMessage = "${customMessage}Expected object to have " + + "className property"; + + referee.expect = function () { + expect.init(referee); + return expect.apply(referee, arguments); + }; + + return referee; +}); \ No newline at end of file diff -Nru node-lolex-1.5.1/debian/node_modules/referee/LICENSE node-lolex-2.2.0/debian/node_modules/referee/LICENSE --- node-lolex-1.5.1/debian/node_modules/referee/LICENSE 1970-01-01 00:00:00.000000000 +0000 +++ node-lolex-2.2.0/debian/node_modules/referee/LICENSE 2018-02-02 13:28:15.000000000 +0000 @@ -0,0 +1,27 @@ +(The BSD License) + +Copyright (c) 2010-2012, Christian Johansen, christian@cjohansen.no and +August Lilleaas, august.lilleaas@gmail.com. All rights reserved. + +Redistribution and use in source and binary forms, with or without modification, +are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, + this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + * Neither the name of Christian Johansen nor the names of his contributors + may be used to endorse or promote products derived from this software + without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND +ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff -Nru node-lolex-1.5.1/debian/node_modules/referee/.npmignore node-lolex-2.2.0/debian/node_modules/referee/.npmignore --- node-lolex-1.5.1/debian/node_modules/referee/.npmignore 1970-01-01 00:00:00.000000000 +0000 +++ node-lolex-2.2.0/debian/node_modules/referee/.npmignore 2018-02-02 13:28:15.000000000 +0000 @@ -0,0 +1,3 @@ +*.log +node_modules +.idea diff -Nru node-lolex-1.5.1/debian/node_modules/referee/package.json node-lolex-2.2.0/debian/node_modules/referee/package.json --- node-lolex-1.5.1/debian/node_modules/referee/package.json 1970-01-01 00:00:00.000000000 +0000 +++ node-lolex-2.2.0/debian/node_modules/referee/package.json 2018-02-02 13:28:15.000000000 +0000 @@ -0,0 +1,54 @@ +{ + "name": "referee", + "version": "1.2.0", + "description": "Assertions for any JavaScript test framework and environment", + "homepage": "http://docs.busterjs.org/en/latest/modules/referee/", + "author": "Christian Johansen", + "contributors": [ + { + "name": "Christian Johansen", + "email": "christian@cjohansen.no", + "url": "http://cjohansen.no" + }, + { + "name": "August Lilleaas", + "email": "august.lilleaas@gmail.com", + "url": "http://augustl.com" + }, + { + "name": "Dave Geddes", + "email": "davidcgeddes@gmail.com" + }, + { + "name": "Malcolm Locke", + "email": "malc@wholemeal.co.nz" + }, + { + "name": "Stein Magnus Jodal", + "email": "stein.magnus@jodal.no" + } + ], + "license": "BSD-3-Clause", + "main": "./lib/referee", + "repository": { + "type": "git", + "url": "https://github.com/busterjs/referee" + }, + "scripts": { + "test": "grunt test" + }, + "dependencies": { + "lodash": "3.x", + "samsam": "1.x", + "bane": "1.x" + }, + "devDependencies": { + "grunt": "0.4.x", + "grunt-buster": "0.4.x", + "grunt-cli": "0.1.x", + "buster": "0.7.x", + "phantomjs": "1.9.x", + "sinon": "1.x", + "when": "3.x" + } +} diff -Nru node-lolex-1.5.1/debian/node_modules/referee/Readme.md node-lolex-2.2.0/debian/node_modules/referee/Readme.md --- node-lolex-1.5.1/debian/node_modules/referee/Readme.md 1970-01-01 00:00:00.000000000 +0000 +++ node-lolex-2.2.0/debian/node_modules/referee/Readme.md 2018-02-02 13:28:15.000000000 +0000 @@ -0,0 +1,57 @@ +# referee + +[![Build status](https://secure.travis-ci.org/busterjs/referee.png?branch=master)](http://travis-ci.org/busterjs/referee) + +**referee** is in your unit tests, deciding who passes and who fails. + +It is a test-framework agnostic assertion and expectation library. +Some highlights: + +- Rich library of assertions +- Symmetric assert/refute (refute is **referee**'s "assert.not*") +- Evented: Emits success and failure events +- Failing assertions throw exceptions by default, but can be configured to not +- API to add custom assertions that provides quite a bit of plumbing for free + +Full documentation: +[docs.busterjs.org/en/latest/modules/referee](http://docs.busterjs.org/en/latest/modules/referee/). + +**referee** works in browsers (including old and rowdy ones, like IE6) and Node. +It will define itself as an AMD module if you want it to (i.e. if there's a +`define` function available). + + +## Changelog + +**1.2.0** (2015-Nov-16) + +* Updated dependencies [#13](https://github.com/busterjs/referee/pull/13) +* Added license info in package.json [#12](https://github.com/busterjs/referee/pull/12) +* A `test` method on assertions, returning a promise which is resolved, when assertion passes, and rejected when it fails; relies on a `Promise` global (shimmable) [#9](https://github.com/busterjs/referee/pull/9) + +**1.1.1** (2014-Dec-12) + +* part of fix for issue [#274 - quoting in assertion failures](https://github.com/busterjs/buster/issues/274) + +**1.1.0** (2014-Oct-31) + +* fix for issue [#402 - referee.expect fails if path.resolve gets stubbed](https://github.com/busterjs/buster/issues/402) + +**1.0.3** (2014-Apr-30) + +* fix for issue [#387 - Referee: assert.exception does not check exception type (when given as string)](https://github.com/busterjs/buster/issues/387) + + +## Developers - Running tests + +### Node + + 1. `npm install` - installs dev dependencies + 1. `npm test` - runs node tests + +### Browsers + + 1. `npm install` - installs dev dependencies + 1. `npm start` - starts buster server + 1. open url [localhost:1111/capture](http://localhost:1111/capture) in the browser(s) you want to test with + 1. `npm run-script test-browser` - runs browser tests diff -Nru node-lolex-1.5.1/debian/node_modules/referee/test/expect-test.js node-lolex-2.2.0/debian/node_modules/referee/test/expect-test.js --- node-lolex-1.5.1/debian/node_modules/referee/test/expect-test.js 1970-01-01 00:00:00.000000000 +0000 +++ node-lolex-2.2.0/debian/node_modules/referee/test/expect-test.js 2018-02-02 13:28:15.000000000 +0000 @@ -0,0 +1,115 @@ +/*jslint maxlen:160*/ +(function (referee, testHelper, buster, sinon) { + if (typeof require === "function" && typeof module === "object") { + referee = require("../lib/referee"); + testHelper = require("./test-helper"); + buster = require("buster"); + sinon = require("sinon"); + } + + var expect = referee.expect; + var assert = buster.referee.assert; + var refute = buster.referee.refute; + + buster.testCase("expect", { + setUp: testHelper.setUp, + tearDown: testHelper.tearDown, + + "should be function": function () { + assert.equals(typeof expect, "function"); + }, + + "should bind assert.equals to argument": function () { + refute.exception(function () { + expect({}).toEqual({}); + }); + }, + + "should fail assertion if a not equals b": function () { + try { + expect({ id: 42 }).toEqual({ bleh: "Nah" }); + throw new Error("Did not throw"); + } catch (e) { + assert.equals(e.message, "[expect.toEqual] [object Object] " + + "expected to be equal to [object Object]"); + } + }, + + "should fail assertion by calling buster.assert.fail": function () { + try { + expect({ id: 42 }).toEqual({ bleh: "Nah" }); + } catch (e) {} + + assert(referee.fail.calledOnce); + }, + + "should emit assertion pass event": function () { + var listener = sinon.spy(); + referee.on("pass", listener); + + expect({ id: 42 }).toEqual({ id: 42 }); + + assert(listener.calledOnce); + }, + + "should emit assertion fail event": function () { + var listener = sinon.spy(); + referee.on("failure", listener); + referee.throwOnFailure = false; + + expect({ id: 42 }).toEqual({ id: 22 }); + + assert(listener.calledOnce); + }, + + "should expose refutation as expectation too": function () { + try { + expect({ id: 42 }).not.toEqual({ id: 42 }); + throw new Error("Did not throw"); + } catch (e) { + assert.equals(e.message, "[expect.not.toEqual] [object Object] " + + "expected not to be equal to [object Object]"); + } + }, + + "should expose all assertions": function () { + var obj = { id: 42 }; + + expect(obj).toBe(obj); + expect(obj).not.toBe({ id: 42 }); + expect(obj).toEqual({ id: 42 }); + expect(obj).not.toEqual({}); + expect(obj).toBeObject(); + expect(false).not.toBeObject(); + expect(function () {}).toBeFunction(); + expect({}).not.toBeFunction(); + expect(null).toBeDefined(); + expect(undefined).not.toBeDefined(); + expect(null).toBeNull(); + expect(42).not.toBeNull(); + expect(obj).toMatch({ id: 42 }); + expect(obj).not.toMatch({ id: 37 }); + expect(function () { + throw new TypeError("Oops"); + }).toThrow("TypeError"); + expect(function () {}).not.toThrow(); + expect({ tagName: "li" }).toHaveTagName("li"); + expect({ tagName: "ol" }).not.toHaveTagName("li"); + expect({ className: "a b c" }).toHaveClassName("b"); + expect({ className: "a b c" }).not.toHaveClassName("d"); + expect(true).toBeTruthy(); + expect(false).not.toBeTruthy(); + expect(false).toBeFalsy(); + expect(true).not.toBeFalsy(); + expect(3).toBeCloseTo(3, 0); + expect(2).not.toBeCloseTo(3, 0.5); + expect(2).toBeGreaterThan(1); + expect(1).not.toBeGreaterThan(2); + expect(1).toBeLessThan(2); + expect(2).not.toBeLessThan(1); + expect([0, 1, 2]).toContain(1); + expect([0, 1, 2]).not.toContain(3); + assert(true, "Avoid 'no assertions'"); + } + }); +}(this.referee, this.testHelper, this.buster, this.sinon)); diff -Nru node-lolex-1.5.1/debian/node_modules/referee/test/referee-test.js node-lolex-2.2.0/debian/node_modules/referee/test/referee-test.js --- node-lolex-1.5.1/debian/node_modules/referee/test/referee-test.js 1970-01-01 00:00:00.000000000 +0000 +++ node-lolex-2.2.0/debian/node_modules/referee/test/referee-test.js 2018-02-02 13:28:15.000000000 +0000 @@ -0,0 +1,1725 @@ +(function (referee, testHelper, buster) { + if (typeof require === "function" && typeof module === "object") { + referee = require("../lib/referee"); + testHelper = require("./test-helper"); + buster = require("buster"); + } + + var assert = buster.referee.assert; + var refute = buster.referee.refute; + + buster.testCase("assert", { + setUp: testHelper.setUp, + tearDown: testHelper.tearDown, + + "allows true": function () { + var okListener = this.spy(); + referee.on("pass", okListener); + + refute.exception(function () { + referee.assert(true); + }); + + assert.calledOnce(okListener); + assert.calledWith(okListener, "assert"); + }, + + "allows truthy values": function () { + refute.exception(function () { + referee.assert({}); + referee.assert([]); + referee.assert("Truthy"); + referee.assert(1); + referee.assert(/a/); + }); + }, + + "allows true with message": function () { + refute.exception(function () { + referee.assert(true, "s'aright"); + }); + }, + + "does not allow false": function () { + var okListener = this.spy(); + referee.on("pass", okListener); + + assert.exception(function () { + referee.assert(false); + }); + + refute.called(okListener); + }, + + "does not allow falsy values": function () { + assert.exception(function () { + referee.assert(""); + }); + + assert.exception(function () { + referee.assert(0); + }); + + assert.exception(function () { + referee.assert(NaN); + }); + + assert.exception(function () { + referee.assert(null); + }); + + assert.exception(function () { + referee.assert(undefined); + }); + }, + + "does not allow false with message": function () { + assert.exception(function () { + referee.assert(false, "Some message"); + }); + }, + + "fails with generated message": function () { + try { + referee.assert(false); + throw new Error("Didn't fail"); + } catch (e) { + assert.equals(e.name, "AssertionError"); + assert.equals(e.message, "[assert] Expected false to be truthy"); + } + }, + + "fails with custom message": function () { + try { + referee.assert(false, "False FTW"); + throw new Error("Didn't fail"); + } catch (e) { + assert.equals(e.name, "AssertionError"); + assert.equals(e.message, "False FTW"); + } + }, + + "updates assertion count": function () { + referee.count = 0; + + try { + referee.assert(true); + referee.assert(false); + } catch (e) {} + + assert.equals(referee.count, 2); + }, + + "formats value with assert.format": function () { + referee.format = this.spy(); + + try { + referee.assert(false); + } catch (e) {} + + assert.calledOnce(referee.format); + assert.calledWith(referee.format, false); + }, + + "fails if not passed arguments": function () { + try { + referee.assert(); + throw new Error("Expected assert to fail"); + } catch (e) { + assert.equals(e.message, "[assert] Expected to receive at least 1 argument"); + } + }, + + "does not throw if not configured to": + testHelper.assertionFailureEventTest(function () { + referee.assert(false); + }) + }); + + buster.testCase("plain asserts", { + "assertions expose plain asserts via method test": function () { + assert.isFunction(referee.assert.equals.test); + }, + "test returns promise": function () { + assert.isFunction(referee.assert.equals.test("", "").then); + }, + "failed resolves to error": function () { + return referee.assert.equals.test("actual", "expected").then(undefined, function (message) { + assert.defined(message); + }); + }, + "proper default failure message": function () { + return referee.assert.equals.test("actual", "expected").then(undefined, function (message) { + assert.equals(message, "[assert.equals] actual expected to be equal to expected"); + }); + }, + "proper custom failure message without args": function () { + return referee.assert.equals.test("actual", + "expected", + "custom message").then(undefined, function (message) { + assert.equals(message, "[assert.equals] custom message: actual expected to be equal to expected"); + }); + }, + "successful resolves success": function () { + return referee.assert.equals.test("expected", "expected").then(function (message) { + assert.equals(message, ["pass", "assert.equals", "expected", "expected"]); + }); + }, + "this.fail works from assertions": function () { + return referee.assert.className.test({}, "Item").then(undefined, function (message) { + assert.equals(message, + "[assert.className] Expected object to have className property"); + }); + } + + }); + + function plainAssertionTests(assertion, type, name, declareTests) { + function withExpected(expected, tests) { + return tests({ + pass: function (actual) { + return function () { + return Promise.resolve(assertion.apply(this, [actual].concat(expected))).then(buster.assert.defined, buster.refute.defined); + } + }, + fail: function (actual) { + return function () { + return Promise.resolve(assertion.apply(this, [actual].concat(expected))).then(buster.refute.defined, buster.assert.defined); + } + }, + yieldMsg: function (expectedMessage, actual) { + return function () { + return Promise.resolve(assertion.apply(this, [actual].concat(expected))).then(buster.refute.defined, function (actualMessage) { + buster.assert.equals(actualMessage, "[" + type + "." + name + "] " + expectedMessage) + }); + } + } + }); + } + + var declared = declareTests(withExpected); + buster.testCase(type + "." + name + ".test", declared); + } + + plainAssertionTests(referee.assert.equals.test, "assert", "equals", function (given) { + return { + "expected string -" : given(["the string"], function (must) { + return { + "pass for equal": must.pass("the string"), + "fail for different": must.fail("different"), + "message is ok": must.yieldMsg("other expected to be equal to the string", "other") + } + }) + }; + }); + + plainAssertionTests(referee.assert.className.test, "assert", "className", function (given) { + return { + "classname -": given(["item"], function (must) { + return { + "fail when element does not include class name" : must.yieldMsg( + "Expected object's className to include item but was ", {className: ""}) + } + }) + } + }); + + plainAssertionTests(referee.refute.tagName.test, "refute", "tagName", function (given) { + return { + "tagname -": given(["li", "Yes"], function (must) { + return { + "fail with custom message if object does not have tagName property" : must.yieldMsg( + "Yes: Expected [object Object] to have tagName property", {}) + } + }) + } + }); + + testHelper.assertionTests("assert", "isTrue", function (pass, fail, msg) { + pass("for true", true); + fail("for false", false); + msg("represent expected value in message", + "[assert.isTrue] Expected [object Object] to be true", {}); + msg("include custom message", + "[assert.isTrue] Oh: Expected [object Object] to be true", + {}, + "Oh"); + fail("for object", {}); + fail("for array", []); + fail("for string", "32"); + fail("for number", 32); + msg("fail if not passed arguments", + "[assert.isTrue] Expected to receive at least 1 argument"); + }); + + testHelper.assertionTests("assert", "isFalse", function (pass, fail, msg, callbacks) { + pass("for false", false); + fail("for true", true); + msg("fail with message", + "[assert.isFalse] Expected true to be false", true); + msg("fail with custom message", + "[assert.isFalse] Nooo! Expected true to be false", true, "Nooo!"); + msg("represent expected value in message", + "[assert.isFalse] Expected [object Object] to be false", {}); + fail("for empty string", ""); + fail("for 0", 0); + fail("for NaN", NaN); + fail("for null", null); + fail("for undefined", undefined); + }); + + var obj = { id: 42 }; + var obj2 = { id: 42 }; + + testHelper.assertionTests("assert", "same", function (pass, fail, msg) { + pass("when comparing object to itself", obj, obj); + fail("when comparing different objects", obj, obj2); + pass("when comparing strings", "Hey", "Hey"); + pass("when comparing booleans", true, true); + pass("when comparing numbers", 32, 32); + pass("when comparing infinity", Infinity, Infinity); + fail("when comparing without coercion", 666, "666"); + fail("when comparing falsy values without coercion", 0, ""); + pass("when comparing null to null", null, null); + pass("when comparing undefined to undefined", undefined, undefined); + msg("include objects in message", + "[assert.same] Obj expected to be the same object as [object Object]", + "Obj", {}); + msg("include custom message", + "[assert.same] Back again: Obj expected to be the same object as [object Object]", + "Obj", {}, "Back again"); + pass("when comparing NaN to NaN", NaN, NaN); + fail("when comparing -0 to +0", -0, +0); + }); + + testHelper.assertionTests("refute", "same", function (pass, fail, msg) { + fail("comparing object to itself", obj, obj); + pass("when comparing different objects", obj, obj2); + fail("when comparing strings", "Hey", "Hey"); + fail("when comparing booleans", true, true); + fail("when comparing numbers", 32, 32); + fail("when comparing infinity", Infinity, Infinity); + fail("when comparing null to null", null, null); + fail("when comparing undefined to undefined", undefined, undefined); + msg("include objects in message", + "[refute.same] [object Object] expected not to be the same object as [object Object]", obj, obj); + msg("include custom message", + "[refute.same] Sigh... [object Object] expected not to be the same object as [object Object]", + obj, obj, "Sigh..."); + fail("when comparing NaN to NaN", NaN, NaN); + pass("when comparing -0 to +0", -0, +0); + }); + + testHelper.assertionTests("assert", "equals", function (pass, fail, msg) { + var func = function () {}; + var arr = []; + var date = new Date(); + var sameDate = new Date(date.getTime()); + var anotherDate = new Date(date.getTime() - 10); + + pass("when comparing object to itself", obj, obj); + pass("when comparing strings", "Hey", "Hey"); + pass("when comparing numbers", 32, 32); + pass("when comparing booleans", false, false); + pass("when comparing null", null, null); + pass("when comparing undefined", undefined, undefined); + pass("when comparing function to itself", func, func); + fail("when comparing functions", function () {}, function () {}); + pass("when comparing array to itself", arr, arr); + pass("when comparing date objects with same date", date, sameDate); + fail("when comparing date objects with different dates", date, anotherDate); + fail("when comparing date objects to null", date, null); + fail("when comparing strings and numbers with coercion", "4", 4); + fail("when comparing numbers and strings with coercion", 4, "4"); + fail("when comparing number object with coercion", 32, new Number(32)); + fail("when comparing number object reverse with coercion", new Number(32), 32); + fail("when comparing falsy values with coercion", 0, ""); + fail("when comparing falsy values reverse with coercion", "", 0); + fail("when comparing string boxing with coercion", "4", new String("4")); + fail("when comparing string boxing reverse with coercion", new String("4"), "4"); + pass("when comparing NaN to NaN", NaN, NaN); + fail("when comparing -0 to +0", -0, +0); + fail("when comparing objects with different own properties", + { id: 42 }, { id: 42, di: 24 }); + fail("when comparing objects with different own properties #2", + { id: undefined }, { di: 24 }); + fail("when comparing objects with different own properties #3", + { id: 24 }, { di: undefined }); + pass("when comparing objects with one property", { id: 42 }, { id: 42 }); + pass("when comparing objects with one object property", + { obj: { id: 42 } }, { obj: { id: 42 } }); + fail("when comparing objects with one property with different values", + { id: 42 }, { id: 24 }); + + var deepObject = { + id: 42, + name: "Hey", + sayIt: function () { + return this.name; + }, + + child: { + speaking: function () {} + } + }; + + pass("when comparing complex objects", deepObject, { + sayIt: deepObject.sayIt, + child: { speaking: deepObject.child.speaking }, + id: 42, + name: "Hey" + }); + + pass("when comparing arrays", + [1, 2, "Hey there", func, { id: 42, prop: [2, 3] }], + [1, 2, "Hey there", func, { id: 42, prop: [2, 3] }]); + + pass("when comparing regexp literals", /a/, /a/); + pass("when comparing regexp objects", new RegExp("[a-z]+"), new RegExp("[a-z]+")); + + var re1 = new RegExp("[a-z]+"); + var re2 = new RegExp("[a-z]+"); + re2.id = 42; + + fail("when comparing nested array with shallow array", [["hey"]], ["hey"]); + fail("when comparing regexp objects with custom properties", re1, re2); + fail("when comparing different objects", { id: 42 }, {}); + fail("when comparing object to null", {}, null); + fail("when comparing object to undefined", {}, undefined); + fail("when comparing object to false", {}, false); + fail("when comparing false to object", false, {}); + fail("when comparing object to true", {}, true); + fail("when comparing true to object", true, {}); + fail("when comparing 'empty' object to date", {}, new Date()); + fail("when comparing 'empty' object to string object", {}, new String()); + fail("when comparing 'empty' object to number object", {}, new Number()); + fail("when comparing 'empty' object to empty array", {}, []); + + function gather() { return arguments; } + var arrayLike = { length: 4, "0": 1, "1": 2, "2": {}, "3": [] }; + + pass("when comparing arguments to array", [1, 2, {}, []], gather(1, 2, {}, [])); + pass("when comparing array to arguments", gather(), []); + + pass("when comparing arguments to array like object", + arrayLike, gather(1, 2, {}, [])); + + msg("fail with understandable message", + "[assert.equals] [object Object] expected to be equal to Hey", {}, "Hey"); + + msg("fail with custom message", + "[assert.equals] Here: [object Object] expected to be equal to Hey", + {}, "Hey", "Here:"); + + msg("fail with special message for multi-line strings", + "[assert.equals] Expected multi-line strings to be equal:\n" + + "line 2: The quick brown fox jumps over the lazy god\n" + + "was: The quick brown fox jumps over the lazy dog", + "Yo!\nThe quick brown fox jumps over the lazy dog", + "Yo!\nThe quick brown fox jumps over the lazy god").expectedFormats = 0; + + msg("fail with custom message for multi-line strings", + "[assert.equals] Slick! Expected multi-line strings to be equal:\n" + + "line 2: The quick brown fox jumps over the lazy god\n" + + "was: The quick brown fox jumps over the lazy dog", + "Yo!\nThe quick brown fox jumps over the lazy dog", + "Yo!\nThe quick brown fox jumps over the lazy god", + "Slick!").expectedFormats = 0; + + msg("fail with special message for multi-line strings with too short actual", + "[assert.equals] Expected multi-line strings to be equal:\n" + + "line 2: The quick brown fox jumps over the lazy god\n" + + "was: ", + "Yo!", + "Yo!\nThe quick brown fox jumps over the lazy god").expectedFormats = 0; + + msg("fail with special message for multi-line strings with too long actual", + "[assert.equals] Expected multi-line strings to be equal:\n" + + "line 2: \n" + + "was: The quick brown fox jumps over the lazy god", + "Yo!\nThe quick brown fox jumps over the lazy god", + "Yo!").expectedFormats = 0; + + msg("fail with all differing lines in multi-line string fail", + "[assert.equals] Expected multi-line strings to be equal:\n" + + "line 1: Yo!\n" + + "was: Yo\n\n" + + "line 4: Hey\n" + + "was: Oh noes", + "Yo\n2\n3\nOh noes", + "Yo!\n2\n3\nHey").expectedFormats = 0; + + msg("fail with regular message for one-line strings", + "[assert.equals] Yo expected to be equal to Hey", + "Yo", "Hey"); + }); + + buster.testCase("assert.equals host objects", { + requiresSupportFor: { "DOM": typeof document !== "undefined" }, + setUp: testHelper.setUp, + tearDown: testHelper.tearDown, + + "should pass when comparing DOM element to itself": function () { + var element = document.createElement("div"); + + refute.exception(function () { + referee.assert.equals(element, element); + }); + }, + + "should fail when comparing different DOM elements": function () { + var div = document.createElement("div"); + var span = document.createElement("span"); + + assert.exception(function () { + referee.assert.equals(div, span); + }); + } + }); + + testHelper.assertionTests("refute", "equals", function (pass, fail, msg) { + fail("when comparing object to itself", obj, obj); + fail("when comparing strings", "Hey", "Hey"); + fail("when comparing numbers", 32, 32); + fail("when comparing booleans", false, false); + fail("when comparing null", null, null); + fail("when comparing undefined", undefined, undefined); + + var func = function () {}; + var arr = []; + var date = new Date(); + var sameDate = new Date(date.getTime()); + var anotherDate = new Date(date.getTime() - 10); + + fail("when comparing function to itself", func, func); + pass("when comparing functions", function () {}, function () {}); + fail("when comparing array to itself", arr, arr); + fail("when comparing date objects with same date", date, sameDate); + pass("when comparing date objects with different dates", date, anotherDate); + pass("when comparing date objects to null", new Date(), null); + pass("when comparing string with number with coercion", "4", 4); + pass("when comparing number with string with coercion", 32, "32"); + pass("when comparing with coercion", 0, ""); + pass("when comparing objects with different own properties", + { id: 42 }, { id: 42, di: 24 }); + pass("when comparing objects with different own properties #2", + { id: undefined }, { di: 24 }); + pass("when comparing objects with different own properties #3", + { id: 24 }, { di: undefined }); + fail("when comparing objects with one property", { id: 42 }, { id: 42 }); + fail("when comparing objects with one object property", + { obj: { id: 42 } }, { obj: { id: 42 } }); + pass("when comparing objects with one property with different values", + { id: 42 }, { id: 24 }); + fail("when comparing NaN to NaN", NaN, NaN); + pass("when comparing -0 to +0", -0, +0); + + var deepObject = { + id: 42, + name: "Hey", + sayIt: function () { + return this.name; + }, + + child: { + speaking: function () {} + } + }; + + fail("when comparing complex objects", deepObject, { + sayIt: deepObject.sayIt, + child: { speaking: deepObject.child.speaking }, + id: 42, + name: "Hey" + }); + + var arr1 = [1, 2, "Hey there", func, { id: 42, prop: [2, 3] }]; + var arr2 = [1, 2, "Hey there", func, { id: 42, prop: [2, 3] }]; + + fail("when comparing arrays", arr1, arr2); + fail("when comparing regexp literals", /a/, /a/); + + fail("when comparing regexp objects", new RegExp("[a-z]+"), new RegExp("[a-z]+")); + + var re1 = new RegExp("[a-z]+"); + var re2 = new RegExp("[a-z]+"); + re2.id = 42; + + pass("when comparing regexp objects with custom properties", re1, re2); + pass("when comparing different objects", obj, {}); + pass("when comparing object to null", {}, null); + pass("when comparing null to object", {}, null); + pass("when comparing object to undefined", {}, undefined); + pass("when comparing undefined to object", undefined, {}); + pass("when comparing object to false", {}, false); + pass("when comparing false to object", false, {}); + pass("when comparing object to true", {}, true); + pass("when comparing true to object", true, {}); + pass("when comparing 'empty' object to date", {}, new Date()); + pass("when comparing 'empty' object to string object", {}, new String()); + pass("when comparing 'empty' object to number object", {}, new Number()); + pass("when comparing 'empty' object to empty array", {}, []); + pass("when comparing multi-line strings", "Hey\nHo", "Yo\nNo"); + + function gather() { return arguments; } + var arrayLike = { length: 4, "0": 1, "1": 2, "2": {}, "3": [] }; + + fail("when comparing arguments to array", [1, 2, {}, []], gather(1, 2, {}, [])); + fail("when comparing array to arguments", gather(), []); + fail("when comparing arguments to array like object", + arrayLike, gather(1, 2, {}, [])); + + msg("fail with understandable message", + "[refute.equals] [object Object] expected not to be equal to [object Object]", {}, {}); + + msg("fail with custom message", + "[refute.equals] Eh? [object Object] expected not to be equal to [object Object]", + {}, {}, "Eh?"); + }); + + testHelper.assertionTests("assert", "greater", function (pass, fail, msg) { + pass("when greater than", 2, 1); + fail("when equal", 1, 1); + fail("when less than", 0, 1); + msg( + "fail with descriptive message", + "[assert.greater] Expected 1 to be greater than 2", + 1, + 2 + ); + }); + + testHelper.assertionTests("refute", "greater", function (pass, fail, msg) { + fail("when greater than", 2, 1); + pass("when equal", 1, 1); + pass("when less than", 0, 1); + msg( + "fail with descriptive message", + "[refute.greater] Expected 2 to be less than or equal to 1", + 2, + 1 + ); + }); + + testHelper.assertionTests("assert", "less", function (pass, fail, msg) { + fail("when greater than", 2, 1); + fail("when equal", 1, 1); + pass("when less than", 0, 1); + msg( + "fail with descriptive message", + "[assert.less] Expected 2 to be less than 1", + 2, + 1 + ); + }); + + testHelper.assertionTests("refute", "less", function (pass, fail, msg) { + pass("when greater than", 2, 1); + pass("when equal", 1, 1); + fail("when less than", 0, 1); + msg( + "fail with descriptive message", + "[refute.less] Expected 1 to be greater than or equal to 2", + 1, + 2 + ); + }); + + testHelper.assertionTests("assert", "isString", function (pass, fail, msg) { + pass("for string", "Hey"); + fail("for object", {}); + msg("fail with descriptive message", + "[assert.isString] Expected [object Object] (object) to be string", + {}); + msg("fail with custom message", + "[assert.isString] Snap: Expected [object Object] (object) to be string", + {}, "Snap"); + }); + + testHelper.assertionTests("refute", "isString", function (pass, fail, msg) { + fail("for string", "Hey"); + pass("for object", {}); + msg("fail with descriptive message", + "[refute.isString] Expected Yo not to be string", + "Yo"); + msg("fail with custom message", + "[refute.isString] Here goes: Expected Yo not to be string", + "Yo", "Here goes"); + }); + + testHelper.assertionTests("assert", "isObject", function (pass, fail, msg) { + pass("for object", {}); + fail("for function", function () {}); + fail("for null", null); + msg("fail with descriptive message", + "[assert.isObject] Hey (string) expected to be object and not null", + "Hey"); + msg("fail with custom message", + "[assert.isObject] OH! Hey (string) expected to be object and not null", + "Hey", "OH!"); + }); + + testHelper.assertionTests("refute", "isObject", function (pass, fail, msg) { + fail("for object", {}); + pass("for function", function () {}); + pass("for null", null); + msg("fail with descriptive message", + "[refute.isObject] [object Object] expected to be null or not an object", + {}); + msg("fail with custom message", + "[refute.isObject] Oh no! [object Object] expected to be null or not an object", + {}, "Oh no!"); + }); + + testHelper.assertionTests("assert", "isFunction", function (pass, fail, msg) { + pass("for function", function () {}); + fail("for object", {}); + msg("fail with descriptive message", + "[assert.isFunction] Hey (string) expected to be function", + "Hey"); + msg("fail with custom message", + "[assert.isFunction] Oh no: Hey (string) expected to be function", + "Hey", "Oh no"); + }); + + testHelper.assertionTests("refute", "isFunction", function (pass, fail, msg) { + fail("for function", function () {}); + pass("for object", {}); + msg("fail with descriptive message", + "[refute.isFunction] function () {} expected not to be function", + function () {}); + msg("fail with custom message", + "[refute.isFunction] Hmm: function () {} expected not to be function", + function () {}, "Hmm"); + }); + + testHelper.assertionTests("assert", "isBoolean", function (pass, fail, msg) { + pass("for boolean", true); + fail("for function", function () {}); + fail("for null", null); + msg("fail with descriptive message", + "[assert.isBoolean] Expected Hey (string) to be boolean", "Hey"); + msg("fail with custom message", + "[assert.isBoolean] Boolean, plz: Expected Hey (string) to be boolean", + "Hey", "Boolean, plz"); + }); + + testHelper.assertionTests("refute", "isBoolean", function (pass, fail, msg) { + fail("for boolean", true); + pass("for function", function () {}); + pass("for null", null); + msg("fail with descriptive message", + "[refute.isBoolean] Expected true not to be boolean", true); + msg("fail with custom message", + "[refute.isBoolean] Here: Expected true not to be boolean", + true, "Here"); + }); + + testHelper.assertionTests("assert", "isNumber", function (pass, fail, msg) { + pass("for number", 32); + fail("for NaN (sic)", NaN); + fail("for function", function () {}); + fail("for null", null); + msg("fail with descriptive message", + "[assert.isNumber] Expected Hey (string) to be a non-NaN number", + "Hey"); + msg("fail with custom message", + "[assert.isNumber] Check it: Expected Hey (string) to be a non-NaN number", + "Hey", "Check it"); + }); + + testHelper.assertionTests("refute", "isNumber", function (pass, fail, msg) { + fail("for number", 32); + pass("for NaN (sic)", NaN); + pass("for function", function () {}); + pass("for null", null); + msg("fail with descriptive message", + "[refute.isNumber] Ho ho! Expected 42 to be NaN or a non-number value", + 42, "Ho ho!"); + }); + + testHelper.assertionTests("assert", "isNaN", function (pass, fail, msg) { + pass("for NaN", NaN); + fail("for number", 32); + fail("for function", function () {}); + fail("for object", {}); + fail("for null", null); + msg("fail with descriptive message", "[assert.isNaN] Expected 32 to be NaN", 32); + msg("fail with custom message", "[assert.isNaN] No! Expected 32 to be NaN", + 32, "No!"); + }); + + testHelper.assertionTests("refute", "isNaN", function (pass, fail, msg) { + fail("for NaN", NaN); + pass("for number", 32); + pass("for function", function () {}); + pass("for object", {}); + pass("for null", null); + msg("fail with descriptive message", + "[refute.isNaN] Expected not to be NaN", NaN); + msg("fail with custom message", + "[refute.isNaN] Hey: Expected not to be NaN", NaN, "Hey"); + }); + + testHelper.assertionTests("assert", "isArray", function (pass, fail, msg) { + function captureArgs() { + return arguments; + } + + var arrayLike = { + length: 4, + "0": "One", + "1": "Two", + "2": "Three", + "3": "Four", + splice: function () {} + }; + + pass("for array", []); + fail("for object", {}); + fail("for arguments", captureArgs()); + fail("for array like", arrayLike); + msg("fail with descriptive message", + "[assert.isArray] Expected [object Object] to be array", {}); + msg("fail with custom message", + "[assert.isArray] Nope: Expected [object Object] to be array", + {}, "Nope"); + }); + + testHelper.assertionTests("refute", "isArray", function (pass, fail, msg) { + function captureArgs() { + return arguments; + } + + var arrayLike = { + length: 4, + "0": "One", + "1": "Two", + "2": "Three", + "3": "Four", + splice: function () {} + }; + + fail("for array", []); + pass("for object", {}); + pass("for arguments", captureArgs()); + pass("for array like", arrayLike); + msg("fail with descriptive message", + "[refute.isArray] Expected 1,2 not to be array", [1, 2]); + msg("fail with custom message", + "[refute.isArray] Hmm: Expected 1,2 not to be array", + [1, 2], "Hmm"); + }); + + testHelper.assertionTests("assert", "isArrayLike", function (pass, fail, msg) { + function captureArgs() { return arguments; } + + var arrayLike = { + length: 4, + "0": "One", + "1": "Two", + "2": "Three", + "3": "Four", + splice: function () {} + }; + + pass("for array", []); + fail("for object", {}); + pass("for arguments", captureArgs()); + pass("for array like", arrayLike); + msg("fail with descriptive message", + "[assert.isArrayLike] Expected [object Object] to be array like", {}); + msg("fail with custom message", + "[assert.isArrayLike] Here! Expected [object Object] to be array like", + {}, "Here!"); + }); + + testHelper.assertionTests("refute", "isArrayLike", function (pass, fail, msg) { + function captureArgs() { return arguments; } + + var arrayLike = { + length: 4, + "0": "One", + "1": "Two", + "2": "Three", + "3": "Four", + splice: function () {} + }; + + fail("for array", []); + pass("for object", {}); + fail("for arguments", captureArgs()); + fail("for array like", arrayLike); + msg("fail with descriptive message", + "[refute.isArrayLike] Expected 1,2 not to be array like", [1, 2]); + msg("fail with custom message", + "[refute.isArrayLike] Hey: Expected 1,2 not to be array like", + [1, 2], "Hey"); + }); + + testHelper.assertionTests("assert", "defined", function (pass, fail, msg) { + fail("for undefined", undefined); + pass("for function", function () {}); + pass("for null", null); + msg("fail with descriptive message", + "[assert.defined] Expected to be defined", undefined); + msg("fail with custom message", + "[assert.defined] Huh? Expected to be defined", + undefined, "Huh?"); + }); + + testHelper.assertionTests("refute", "defined", function (pass, fail, msg) { + pass("for undefined", undefined); + fail("for function", function () {}); + fail("for null", null); + msg("fail with descriptive message", + "[refute.defined] Expected Hey (string) not to be defined", + "Hey"); + msg("fail with custom message", + "[refute.defined] Yawn... Expected Hey (string) not to be defined", + "Hey", "Yawn..."); + }); + + testHelper.assertionTests("assert", "isNull", function (pass, fail, msg) { + pass("for null", null); + fail("for function", function () {}); + fail("for undefined", undefined); + msg("fail with descriptive message", + "[assert.isNull] Expected Hey to be null", "Hey").expectedFormats = 1; + msg("fail with custom message", + "[assert.isNull] Hmm: Expected Hey to be null", + "Hey", "Hmm").expectedFormats = 1; + }); + + testHelper.assertionTests("refute", "isNull", function (pass, fail, msg) { + fail("for null", null); + pass("for function", function () {}); + pass("for undefined", undefined); + msg("fail with descriptive message", + "[refute.isNull] Expected not to be null", null).expectedFormats = 0; + msg("fail with custom message", + "[refute.isNull] Here: Expected not to be null", + null, "Here").expectedFormats = 0; + }); + + testHelper.assertionTests("assert", "match", function (pass, fail, msg) { + pass("matching regexp", "Assertions", /[a-z]/); + pass("for generic object with test method returning true", "Assertions", { + test: function () { + return true; + } + }); + + fail("for non-matching regexp", "Assertions 123", /^[a-z]$/); + pass("matching boolean", true, true); + fail("mis-matching boolean", true, false); + + fail("for generic object with test method returning false", { + test: function () { + return false; + } + }, "Assertions"); + + msg("fail with understandable message", + "[assert.match] Assertions 123 expected to match /^[a-z]+$/", + "Assertions 123", /^[a-z]+$/); + + msg("fail with custom message", + "[assert.match] Yeah! Assertions 123 expected to match /^[a-z]+$/", + "Assertions 123", /^[a-z]+$/, "Yeah!"); + + fail("if match object is null", "Assertions 123", null); + + fail("if match object is undefined", "Assertions 123", undefined); + + fail("with custom message if match object is undefined", + "Assertions 123", undefined, "No"); + + fail("if match object is false", "Assertions 123", false); + fail("if matching a number against a string", "Assertions 123", 23); + fail("if matching a number against a similar string", "23", 23); + pass("if matching a number against itself", 23, 23); + + pass("if matcher is a function that returns true", + "Assertions 123", function (obj) { return true; }); + + fail("if matcher is a function that returns false", + "Assertions 123", function (obj) { return false; }); + + fail("if matcher is a function that returns falsy", + "Assertions 123", function () {}); + + fail("if matcher does not return explicit true", + "Assertions 123", function () { return "Hey"; }); + + this["should call matcher with assertion argument"] = function () { + var listener = this.stub().returns(true); + + referee.assert.match("Assertions 123", listener); + + assert.calledWith(listener, "Assertions 123"); + }; + + pass("if matcher is substring of matchee", "Diskord", "or"); + pass("if matcher is string equal to matchee", "Diskord", "Diskord"); + pass("for strings ignoring case", "Look ma, case-insensitive", + "LoOk Ma, CaSe-InSenSiTiVe"); + + fail("if match string is not substring of matchee", "Vim", "Emacs"); + fail("if match string is not substring of object", {}, "Emacs"); + + fail("if matcher is substring of object.toString", "Emacs", { + toString: function () { + return "Emacs"; + } + }); + + fail("for null and empty string", null, ""); + fail("for undefined and empty string", undefined, ""); + fail("for false and empty string", false, ""); + fail("for 0 and empty string", 0, ""); + fail("for NaN and empty string", NaN, ""); + + var object = { + id: 42, + name: "Christian", + doIt: "yes", + + speak: function () { + return this.name; + } + }; + + pass("if object contains all properties in matcher", object, { + id: 42, + doIt: "yes" + }); + + var object2 = { + id: 42, + name: "Christian", + doIt: "yes", + owner: { + someDude: "Yes", + hello: "ok" + }, + + speak: function () { + return this.name; + } + }; + + pass("for nested matcher", object2, { + owner: { + someDude: "Yes", + hello: function (value) { + return value === "ok"; + } + } + }); + + pass("for empty strings", "", ""); + pass("for empty strings as object properties", { foo: "" }, { foo: "" }); + pass("for similar arrays", [1, 2, 3], [1, 2, 3]); + pass("for array subset", [1, 2, 3], [2, 3]); + pass("for single-element array subset", [1, 2, 3], [1]); + pass("for matching array subset", [1, 2, 3, { id: 42 }], [{ id: 42 }]); + fail("for mis-matching array 'subset'", [1, 2, 3], [2, 3, 4]); + fail("for mis-ordered array 'subset'", [1, 2, 3], [1, 3]); + }); + + testHelper.assertionTests("refute", "match", function (pass, fail, msg) { + fail("matching regexp", "Assertions", /[a-z]/); + fail("generic object with test method returning true", "Assertions", { + test: function () { + return true; + } + }); + + pass("for non-matching regexp", "Assertions 123", /^[a-z]$/); + + pass("for generic object with test method returning false", "Assertions", { + test: function () { + return false; + } + }); + + msg("fail with understandable message", + "[refute.match] Assertions 123 expected not to match /^.+$/", + "Assertions 123", /^.+$/); + msg("fail with custom message", + "[refute.match] NO! Assertions 123 expected not to match /^.+$/", + "Assertions 123", /^.+$/, "NO!"); + + pass("if match object is null", "Assertions 123", null); + pass("if match object is undefined", "Assertions 123", undefined); + pass("if match object is false", "Assertions 123", false); + pass("if matching a number against a string", "Assertions 123", 23); + fail("if matching a number against a similar string", 23, "23"); + fail("if matching a number against itself", 23, 23); + fail("if matcher is a function that returns true", "Assertions 123", + function (obj) { return true; }); + + pass("if matcher is a function that returns false", + "Assertions 123", function (obj) { return false; }); + + pass("if matcher is a function that returns falsy", + "Assertions 123", function () {}); + + pass("if matcher does not return explicit true", + "Assertions 123", function () { return "Hey"; }); + + this["should call matcher with assertion argument"] = function () { + var listener = this.stub().returns(false); + + referee.refute.match("Assertions 123", listener); + + assert.calledWith(listener, "Assertions 123"); + }; + + fail("if matcher is substring of matchee", "Diskord", "or"); + fail("if matcher is string equal to matchee", "Diskord", "Diskord"); + pass("if match string is not substring of matchee", "Vim", "Emacs"); + pass("if match string is not substring of object", {}, "Emacs"); + + pass("if matcher is substring of object.toString", "Emacs", { + toString: function () { + return "Emacs"; + } + }); + + pass("if matching an empty string with null", null, ""); + pass("if matching an empty string with undefined", undefined, ""); + pass("if matching an empty string with false", false, ""); + pass("if matching an empty string with 0", 0, ""); + pass("if matching an empty string with NaN", NaN, ""); + + var object = { + id: 42, + name: "Christian", + doIt: "yes", + + speak: function () { + return this.name; + } + }; + + fail("if object contains all properties in matcher", object, { + id: 42, + doIt: "yes" + }); + + var object2 = { + id: 42, + name: "Christian", + doIt: "yes", + owner: { + someDude: "Yes", + hello: "ok" + }, + + speak: function () { + return this.name; + } + }; + + fail("for nested matcher", object2, { + owner: { + someDude: "Yes", + hello: function (value) { + return value === "ok"; + } + } + }); + + var object3 = { + id: 42, + name: "Christian", + doIt: "yes", + owner: { + someDude: "Yes", + hello: "ok" + }, + + speak: function () { + return this.name; + } + }; + + pass("for nested matcher with mismatching properties", object3, { + owner: { + someDude: "No", + hello: function (value) { + return value === "ok"; + } + } + }); + + fail("for similar arrays", [1, 2, 3], [1, 2, 3]); + fail("for array subset", [1, 2, 3], [2, 3]); + fail("for single-element array subset", [1, 2, 3], [1]); + fail("for matching array subset", [1, 2, 3, { id: 42 }], [{ id: 42 }]); + pass("for mis-matching array 'subset'", [1, 2, 3], [2, 3, 4]); + pass("for mis-ordered array 'subset'", [1, 2, 3], [1, 3]); + }); + + testHelper.assertionTests("assert", "keys", function (pass, fail, msg) { + function Class(o) { + for (var key in o) { + if (o.hasOwnProperty(key)) { + this[key] = o[key]; + } + } + } + Class.prototype.methodA = function () {}; + Class.prototype.methodB = function () {}; + + pass("when keys are exact", {a: 1, b: 2, c: 3}, ['a', 'b', 'c']); + fail("when keys are missing", {a: 1, b: 2, c: 3}, ['a', 'b']); + fail("when keys are excess", {a: 1, b: 2, c: 3}, ['a', 'b', 'c', 'd']); + fail("when keys are not exact", {a: 1, b: 2, c: 3}, ['a', 'b', 'd']); + pass("when there are no keys", {}, []); + pass("when values are special", {a: -1, b: null, c: undefined}, ['a', 'b', 'c']); + pass("and ignore object methods", new Class({a: 1, b: 2, c: 3}), ['a', 'b', 'c']); + pass("and allow overwriting object methods", + new Class({a: 1, methodA: 2}), ['a', 'methodA']); + + msg("fail with message", + "[assert.keys] Expected [object Object] to have exact keys a,b", + {a: 1, b: 2, c: 3}, ['a', 'b']); + + msg("fail with custom message", + "[assert.keys] Too bad: Expected [object Object] to have exact keys a,b", + {a: 1, b: 2, c: 3}, ['a', 'b'], "Too bad"); + }); + + testHelper.assertionTests("refute", "keys", function (pass, fail, msg) { + function Class(o) { + for (var key in o) { + if (o.hasOwnProperty(key)) { + this[key] = o[key]; + } + } + } + Class.prototype.methodA = function () {}; + Class.prototype.methodB = function () {}; + + fail("when keys are exact", {a: 1, b: 2, c: 3}, ['a', 'b', 'c']); + pass("when keys are missing", {a: 1, b: 2, c: 3}, ['a', 'b']); + pass("when keys are excess", {a: 1, b: 2, c: 3}, ['a', 'b', 'c', 'd']); + pass("when keys are not exact", {a: 1, b: 2, c: 3}, ['a', 'b', 'd']); + fail("when there are no keys", {}, []); + fail("when values are special", {a: -1, b: null, c: undefined}, ['a', 'b', 'c']); + fail("and ignore object methods", new Class({a: 1, b: 2, c: 3}), ['a', 'b', 'c']); + fail("and allow overwriting object methods", + new Class({a: 1, methodA: 2}), ['a', 'methodA']); + + msg("fail with message", + "[refute.keys] Expected not to have exact keys a,b,c", + {a: 1, b: 2, c: 3}, ['a', 'b', 'c']); + + msg("fail with custom message", + "[refute.keys] Too bad: Expected not to have exact keys a,b,c", + {a: 1, b: 2, c: 3}, ['a', 'b', 'c'], "Too bad"); + }); + + testHelper.assertionTests("assert", "exception", function (pass, fail, msg) { + pass("when callback throws", function () { throw new Error(); }); + fail("when callback does not throw", function () {}); + + msg("fail with message", "[assert.exception] Expected exception", + function () {}).expectedFormats = 0; + + pass("when callback throws expected name", function () { + throw new TypeError("Oh hmm"); + }, { name: "TypeError" }); + + fail("when callback does not throw expected name", function () { + throw new Error(); + }, { name: "TypeError" }); + + fail("when thrown message does not match", function () { + throw new Error("Aright"); + }, { message: "Aww" }); + + pass("when message and type matches", function () { + throw new TypeError("Aright"); + }, { name: "Type", message: "Ar" }); + + fail("when callback does not throw and specific type is expected", + function () {}, { name: "TypeError" }); + + msg("fail with message when not throwing", + "[assert.exception] Expected [object Object] but no exception was thrown", + function () {}, { name: "TypeError" }).expectedFormats = 1; + + msg("fail with custom message", + "[assert.exception] Hmm: Expected exception", + function () {}, "Hmm").expectedFormats = 0; + + msg("fail with matcher and custom message", + "[assert.exception] Hmm: Expected [object Object] but no exception was thrown", + function () {}, { name: "TypeError" }, "Hmm").expectedFormats = 1; + + pass("when matcher function returns true", function () { + throw new TypeError("Aright"); + }, function (err) { return err.name === "TypeError"; }); + + fail("when matcher function returns truthy", function () { + throw new TypeError("Aright"); + }, function (err) { return err.name; }); + + fail("when matcher function returns false", function () { + throw new TypeError("Aright"); + }, function (err) { return err.name === "Error"; }); + + msg("when matcher function fails", + "[assert.exception] Expected thrown TypeError (Aright) to pass matcher function", + function () { + throw new TypeError("Aright"); + }, function (err) { return err.name === "Error"; }).expectedFormats = 0; + + msg("if not passed arguments", + "[assert.exception] Expected to receive at least 1 argument"); + }); + + buster.testCase("assert.exception unexpected exception", { + "fails with custom message": function () { + try { + referee.assert.exception(function () { + throw new Error(":("); + }, { name: "TypeError" }, "Wow"); + throw new Error("Expected to throw"); + } catch (e) { + assert.match(e.message, "[assert.exception] Wow: Expected " + + "[object Object] but threw Error " + + "(:()\nError: :(\n"); + } + }, + + "fails with custom message when message is wrong": function () { + try { + referee.assert.exception(function () { + throw new Error(":("); + }, { name: "Error", message: "Aww" }, "Wow"); + throw new Error("Expected to throw"); + } catch (e) { + assert.match(e.message, "[assert.exception] Wow: Expected " + + "[object Object] but threw " + + "Error (:()\nError: :(\n"); + } + } + }); + + testHelper.assertionTests("refute", "exception", function (pass, fail, msg) { + fail("when callback throws", function () { + throw new Error("Yo, Malcolm"); + }); + + pass("when callback does not throw", function () {}); + pass("with message when callback does not throw", function () {}, "Oh noes"); + + msg("fail with message", + "[refute.exception] Expected not to throw but threw Error (:()", + function () { throw new Error(":("); }); + + msg("fail with custom message", + "[refute.exception] Jeez: Expected not to throw but threw Error (:()", + function () { + throw new Error(":("); + }, "Jeez"); + + msg("fail if not passed arguments", + "[refute.exception] Expected to receive at least 1 argument"); + }); + + testHelper.assertionTests("assert", "tagName", function (pass, fail, msg) { + pass("for matching tag names", { tagName: "li" }, "li"); + pass("for case-insensitive matching tag names", { tagName: "LI" }, "li"); + pass("for case-insensitive matching tag names #2", { tagName: "li" }, "LI"); + pass("for uppercase matching tag names", { tagName: "LI" }, "LI"); + fail("for non-matching tag names", { tagName: "li" }, "p"); + fail("for substring matches in tag names", { tagName: "li" }, "i"); + + msg("fail with message", + "[assert.tagName] Expected tagName to be p but was li", + { tagName: "li" }, "p"); + + msg("fail with custom message", + "[assert.tagName] Here: Expected tagName to be p but was li", + { tagName: "li" }, "p", "Here"); + + msg("fail if not passed arguments", + "[assert.tagName] Expected to receive at least 2 arguments"); + + msg("fail if not passed tag name", + "[assert.tagName] Expected to receive at least 2 arguments", + { tagName: ""}).expectedFormats = 0; + + msg("fail if object does not have tagName property", + "[assert.tagName] Expected [object Object] to have tagName property", + {}, "li"); + + msg("fail with custom message if object does not have tagName property", + "[assert.tagName] Yikes! Expected [object Object] to have tagName property", + {}, "li", "Yikes!"); + + if (typeof document !== "undefined") { + pass("for DOM elements", document.createElement("li"), "li"); + } + }); + + testHelper.assertionTests("refute", "tagName", function (pass, fail, msg) { + fail("for matching tag names", { tagName: "li" }, "li"); + fail("for case-insensitive matching tag names", { tagName: "LI" }, "li"); + fail("for case-insensitive matching tag names #2", { tagName: "LI" }, "li"); + fail("for same casing matching tag names", { tagName: "li" }, "li"); + pass("for non-matching tag names", { tagName: "li" }, "p"); + pass("for substring matching tag names", { tagName: "li" }, "i"); + pass("for case-insensitive non-matching tag names", { tagName: "li" }, "P"); + pass("for case-insensitive substring mathcing tag names", + { tagName: "li" }, "i"); + + msg("fail with message", + "[refute.tagName] Expected tagName not to be li", + { tagName: "li" }, "li"); + + msg("fail with custom message", + "[refute.tagName] Oh well: Expected tagName not to be li", + { tagName: "li" }, "li", "Oh well"); + + msg("fail if not passed arguments", + "[refute.tagName] Expected to receive at least 2 arguments"); + + msg("fail if not passed tag name", + "[refute.tagName] Expected to receive at least 2 arguments", + { tagName: "p" }).expectedFormats = 0; + + msg("fail if object does not have tagName property", + "[refute.tagName] Expected [object Object] to have tagName property", + {}, "li"); + + msg("fail with custom message if object does not have tagName property", + "[refute.tagName] Yes: Expected [object Object] to have tagName property", + {}, "li", "Yes"); + + if (typeof document !== "undefined") { + pass("for DOM elements", document.createElement("li"), "p"); + } + }); + + testHelper.assertionTests("assert", "className", function (pass, fail, msg) { + msg("fail without arguments", + "[assert.className] Expected to receive at least 2 arguments"); + + msg("fail without class name", + "[assert.className] Expected to receive at least 2 arguments", + { className: "" }).expectedFormats = 0; + + msg("fail if object does not have className property", + "[assert.className] Expected object to have className property", + {}, "item"); + + msg("fail with custom message if object does not have className property", + "[assert.className] Nope: Expected object to have className property", + {}, "item", "Nope"); + + msg("fail when element does not include class name", + "[assert.className] Expected object's className to include item but was ", + { className: "" }, "item"); + + msg("fail with custom message when element does not include class name", + "[assert.className] Come on! Expected object's className to include item but was ", + { className: "" }, "item", "Come on!"); + + pass("when element's class name matches", { className: "item" }, "item"); + pass("when element includes class name", { className: "feed item" }, "item"); + fail("when element does not include all class names", + { className: "feed item" }, "item post"); + + pass("when element includes all class names", + { className: "feed item post" }, "item post"); + + pass("when element includes all class names in different order", + { className: "a b c d e" }, "e a d"); + + pass("with class names as array", { className: "a b c d e" }, ["e", "a", "d"]); + + if (typeof document !== "undefined") { + var li = document.createElement("li"); + li.className = "some thing in here"; + + pass("for DOM elements", li, "thing some"); + } + }); + + testHelper.assertionTests("refute", "className", function (pass, fail, msg) { + msg("fail without arguments", + "[refute.className] Expected to receive at least 2 arguments"); + + msg("fail without class name", + "[refute.className] Expected to receive at least 2 arguments", + { className: "item" }).expectedFormats = 0; + + msg("fail if object does not have className property", + "[refute.className] Expected object to have className property", + {}, "item"); + + msg("fail with custom message if object does not have className property", + "[refute.className] Yikes: Expected object to have className property", + {}, "item", "Yikes"); + + pass("when element does not include class name", { className: "" }, "item"); + + msg("fail when element's class name matches", + "[refute.className] Expected object's className not to include item", + { className: "item" }, "item"); + + msg("fail with custom message when element's class name matches", + "[refute.className] Noes: Expected object's className not to include item", + { className: "item" }, "item", "Noes"); + + fail("when element includes class name", { className: "feed item" }, "item"); + pass("when element does not include all class names", + { className: "feed item" }, "item post"); + fail("when element includes all class names", + { className: "feed item post" }, "item post"); + fail("when element includes all class names in different order", + { className: "a b c d e" }, "e a d"); + fail("with class names as array", { className: "a b c d e" }, ["e", "a", "d"]); + pass("with class names as array", { className: "a b c d e" }, ["f", "a", "d"]); + + if (typeof document !== "undefined") { + var li = document.createElement("li"); + li.className = "some thing in here"; + + pass("for DOM elements", li, "something"); + } + }); + + testHelper.assertionTests("assert", "near", function (pass, fail, msg) { + pass("for equal numbers", 3, 3, 0); + fail("for numbers out of delta range", 2, 3, 0.5); + msg("fail with descriptive message", + "[assert.near] Expected 3 to be equal to 2 +/- 0.6", 3, 2, 0.6); + msg("fail with custom message", + "[assert.near] Ho! Expected 3 to be equal to 2 +/- 0.6", + 3, 2, 0.6, "Ho!"); + pass("for numbers in delta range", 2, 3, 1); + msg("fail if not passed arguments", + "[assert.near] Expected to receive at least 3 arguments"); + }); + + testHelper.assertionTests("refute", "near", function (pass, fail, msg) { + fail("for equal numbers", 3, 3, 0); + pass("for numbers out of delta range", 2, 3, 0.5); + msg("with descriptive message", + "[refute.near] Expected 3 not to be equal to 3 +/- 0", 3, 3, 0); + msg("with custom message", + "[refute.near] Hey: Expected 3 not to be equal to 3 +/- 0", + 3, 3, 0, "Hey"); + fail("for numbers in delta range", 2, 3, 1); + msg("fail if not passed arguments", + "[refute.near] Expected to receive at least 3 arguments"); + }); + + function MyThing() {} + var myThing = new MyThing(); + var otherThing = {}; + function F() {} + F.prototype = myThing; + var specializedThing = new F(); + + testHelper.assertionTests("assert", "hasPrototype", function (pass, fail, msg) { + fail("when object does not inherit from prototype", otherThing, MyThing.prototype); + fail("when primitive does not inherit from prototype", 3, MyThing.prototype); + fail("with only one object", {}); + pass("when object has other object on prototype chain", myThing, MyThing.prototype); + pass("when not directly inheriting", specializedThing, MyThing.prototype); + msg("with descriptive message", + "[assert.hasPrototype] Expected [object Object] to have [object Object] on its prototype chain", otherThing, MyThing.prototype); + msg("with custom message", + "[assert.hasPrototype] Oh: Expected [object Object] to have [object Object] on its prototype chain", + otherThing, MyThing.prototype, "Oh"); + msg("fail if not passed arguments", + "[assert.hasPrototype] Expected to receive at least 2 arguments"); + }); + + testHelper.assertionTests("refute", "hasPrototype", function (pass, fail, msg) { + fail("when object inherits from prototype", myThing, MyThing.prototype); + fail("when not inheriting 'indirectly'", specializedThing, MyThing.prototype); + fail("with only one object", {}); + pass("when primitive does not inherit from prototype", 3, MyThing.prototype); + pass("when object does not inherit", otherThing, MyThing.prototype); + msg("with descriptive message", + "[refute.hasPrototype] Expected [object Object] not to have [object Object] on its prototype chain", myThing, MyThing.prototype); + msg("with descriptive message", + "[refute.hasPrototype] Oh: Expected [object Object] not to have [object Object] on its prototype chain", + myThing, MyThing.prototype, "Oh"); + msg("fail if not passed arguments", + "[refute.hasPrototype] Expected to receive at least 2 arguments"); + }); + + testHelper.assertionTests("assert", "contains", function (pass, fail, msg) { + pass("when array contains value", [0, 1, 2], 1); + fail("when array does not contain value", [0, 1, 2], 3); + msg("with descriptive message", + "[assert.contains] Expected [0,1,2] to contain 3", [0, 1, 2], 3); + var thing = {}; + var otherThing = {}; + pass("when array contains the actual object", [thing], thing); + fail("when array contains different object with same value", + [thing], otherThing); + }); + + testHelper.assertionTests("refute", "contains", function (pass, fail, msg) { + fail("when array contains value", [0, 1, 2], 1); + pass("when array does not contain value", [0, 1, 2], 3); + msg("with descriptive message", + "[refute.contains] Expected [0,1,2] not to contain 2", [0, 1, 2], 2); + var thing = {}; + var otherThing = {}; + fail("when array contains the actual object", [thing], thing); + pass("when array contains different object with same value", + [thing], otherThing); + }); + + buster.testCase("CustomAssertionsTest", { + setUp: testHelper.setUp, + tearDown: function () { + testHelper.tearDown.call(this); + delete referee.assert.custom; + delete referee.refute.custom; + }, + + "should expose properties on this as message values": function () { + referee.add("custom", { + assert: function (actual, expected) { + this.actual = actual + "?"; + this.expected = expected + "!"; + return false; + }, + assertMessage: "${actual} ${expected}" + }); + + try { + referee.assert.custom(2, 3); + throw new Error("Didn't throw"); + } catch (e) { + assert.equals("[assert.custom] 2? 3!", e.message); + } + }, + + "should format interpolated property with format": function () { + referee.add("custom", { + assert: function (actual, expected) { + this.actual = actual + "?"; + this.expected = expected + "!"; + return false; + }, + assertMessage: "${actual} ${expected}" + }); + + try { + referee.assert.custom(2, 3); + } catch (e) {} + + assert.calledWith(referee.format, "2?"); + assert.calledWith(referee.format, "3!"); + }, + + "should not expose fail property": function () { + referee.add("custom", { + assert: function (actual, expected) { + return false; + }, + assertMessage: "${fail}" + }); + + try { + referee.assert.custom(2, 3); + throw new Error("Didn't throw"); + } catch (e) { + assert.equals("[assert.custom] ${fail}", e.message); + } + }, + + "should not leak properties between calls": function () { + var i = 0; + + referee.add("custom", { + assert: function (actual, expected) { + if (i === 0) { + this.actual = "A"; + } else { + this.expected = "B"; + } + + i++; + return false; + }, + assertMessage: "${actual} ${expected}" + }); + + try { + referee.assert.custom(4, 5); + } catch (e) {} + + try { + referee.assert.custom(2, 3); + throw new Error("Didn't throw"); + } catch (err) { + assert.equals("[assert.custom] ${actual} B", err.message); + } + }, + + "should interpolate same property multiple times": function () { + referee.add("custom", { + assert: function (actual, expected) { + this.actual = actual + "?"; + return false; + }, + assertMessage: "${actual} ${actual}" + }); + + try { + referee.assert.custom(2, 3); + throw new Error("Didn't throw"); + } catch (e) { + assert.equals("[assert.custom] 2? 2?", e.message); + } + }, + + "should interpolate numeric placeholders multiple times": function () { + referee.add("custom", { + assert: function (actual, expected) { + this.actual = actual + "?"; + return false; + }, + assertMessage: "${0} ${0}" + }); + + try { + referee.assert.custom(2, 3); + throw new Error("Didn't throw"); + } catch (e) { + assert.equals("[assert.custom] 2 2", e.message); + } + }, + + "should add expectation if expect property is set": function () { + referee.add("custom", { + assert: function (actual) { + return actual === "foo"; + }, + assertMessage: "Expected ${1} to be foo!", + refuteMessage: "Expected not to be foo!", + expectation: "toBeFoo" + }); + + refute.exception(function () { + referee.expect("foo").toBeFoo(); + }); + } + }); +}(this.referee, this.testHelper, this.buster)); \ No newline at end of file diff -Nru node-lolex-1.5.1/debian/node_modules/referee/test/test-helper.js node-lolex-2.2.0/debian/node_modules/referee/test/test-helper.js --- node-lolex-1.5.1/debian/node_modules/referee/test/test-helper.js 1970-01-01 00:00:00.000000000 +0000 +++ node-lolex-2.2.0/debian/node_modules/referee/test/test-helper.js 2018-02-02 13:28:15.000000000 +0000 @@ -0,0 +1,206 @@ +var testHelper = (function (referee, buster) { + if (typeof module === "object" && typeof require === "function") { + referee = require("../lib/referee"); + buster = require("buster"); + } + + var assert = buster.referee.assert; + var refute = buster.referee.refute; + + function slice(args, index) { + return Array.prototype.slice.call(args, index); + } + + function assertFailureEvent(callback) { + var fails = this.failListener.callCount; + var passes = this.okListener.callCount; + referee.throwOnFailure = false; + + try { + callback(); + } catch (e) { + assert.fail("Assertion threw when it should not: " + e.message); + } + + assert.equals(this.failListener.callCount, fails + 1, + "Fail listener was not called once: " + + this.failListener.callCount - fails); + assert.equals(this.okListener.callCount, passes, + "Pass listener was unexpectedly called"); + } + + function assertionFailureEventTest(callback) { + return function () { + assertFailureEvent.call(this, callback); + }; + } + + function passingAssertionTest(type, assertion, args) { + return function () { + var initialCount = referee.count; + var callStr = type + "." + assertion + "(" + args.join(", ") + ")"; + + try { + referee[type][assertion].apply(referee, args); + } catch (e) { + if (typeof console !== "undefined") { + console.log("Failed: " + callStr); + } else { + buster.util.puts("Failed: " + callStr); + } + } + + assert.equals( + this.okListener.callCount, + 1, + "Expected referee to emit the pass event once for " + callStr + ); + assert.calledWith(this.okListener, type + "." + assertion); + assert.equals(referee.count - initialCount, 1); + refute.called(referee.fail); + refute.called(this.failListener); + }; + } + + function failingAssertionTest(type, assertion, args) { + return function () { + var initialCount = referee.count; + var callStr = type + "." + assertion + "(" + args.join(", ") + ")"; + + try { + referee[type][assertion].apply(referee, args); + + if (typeof console !== "undefined") { + console.log("Unexpectedly passed: " + callStr); + } else { + buster.util.puts("Unexpectedly passed: " + callStr); + } + } catch (e) {} + + assert.equals( + referee.fail.callCount, + 1, + "Expected referee.fail to be called once for " + + callStr + ", was called " + referee.fail.callCount + + " times" + ); + + assert.equals(referee.count - initialCount, 1); + refute.called(this.okListener); + assert.calledOnce(this.failListener); + + assertFailureEvent.call(this, function () { + referee[type][assertion].apply(referee, args); + }); + }; + } + + function assertionMessageTest(type, assertion, message, args) { + var test = function () { + var msg; + + try { + referee[type][assertion].apply(referee, args); + throw new Error(type + "." + assertion + " expected to fail"); + } catch (e) { + assert.equals(e.name, "AssertionError", + e.name + ": " + e.message); + assert.equals( + e.message, + message, + "Message was " + e.message + ", " + "expected " + message + ); + msg = e.message; + } + + var expected = test.expectedFormats; + + if (typeof expected !== "number") { + expected = args.length; + + if (typeof args[args.length - 1] === "string") { + expected -= 1; + } + } + + assert(referee.format.callCount >= expected); + + var i, l; + for (i = 0, l = expected; i < l; ++i) { + if (!isNaN(args[i]) || !isNaN(referee.format.args[i][0])) { + assert.calledWith(referee.format, args[i]); + } + } + + assert.equals(this.failListener.args[0][0].name, "AssertionError"); + assert.equals(this.failListener.args[0][0].message, msg); + }; + + return test; + } + + function assertionTests(type, assertion, callback) { + var tests = { + setUp: testHelper.setUp, + tearDown: testHelper.tearDown + }; + + var prefix = type + "." + assertion + " should "; + + function pass(name) { + tests[prefix + "pass " + name] = passingAssertionTest( + type, + assertion, + slice(arguments, 1), + name + ); + } + + function fail(name) { + tests[prefix + "fail " + name] = + failingAssertionTest(type, assertion, slice(arguments, 1)); + } + + function msg(name, message) { + tests[prefix + name] = assertionMessageTest( + type, + assertion, + message, + slice(arguments, 2) + ); + + return tests[prefix + name]; + } + + callback.call(tests, pass, fail, msg); + return buster.testCase(type + "." + assertion, tests); + } + + return { + setUp: function () { + this.spy(referee, "fail"); + + referee.format = this.spy(function (object) { + return String(object); + }); + + this.okListener = this.spy(); + referee.on("pass", this.okListener); + this.failListener = this.spy(); + referee.on("failure", this.failListener); + }, + + tearDown: function () { + delete referee.listeners; + referee.count = 0; + delete referee.throwOnFailure; + }, + + assertionFailureEventTest: assertionFailureEventTest, + assertionTests: assertionTests + }; +}(this.referee, this.buster)); + +if (typeof module === "object") { + module.exports = testHelper; +} diff -Nru node-lolex-1.5.1/debian/node_modules/referee/.travis.yml node-lolex-2.2.0/debian/node_modules/referee/.travis.yml --- node-lolex-1.5.1/debian/node_modules/referee/.travis.yml 1970-01-01 00:00:00.000000000 +0000 +++ node-lolex-2.2.0/debian/node_modules/referee/.travis.yml 2018-02-02 13:28:15.000000000 +0000 @@ -0,0 +1,9 @@ +language: node_js +sudo: false +node_js: + - "0.10" + - "0.12" + - "4" + - "5" +before_install: + - npm i -g npm diff -Nru node-lolex-1.5.1/debian/patches/fix-package-json.patch node-lolex-2.2.0/debian/patches/fix-package-json.patch --- node-lolex-1.5.1/debian/patches/fix-package-json.patch 2016-10-12 11:44:44.000000000 +0000 +++ node-lolex-2.2.0/debian/patches/fix-package-json.patch 1970-01-01 00:00:00.000000000 +0000 @@ -1,9 +0,0 @@ ---- a/package.json -+++ b/package.json -@@ -30,5 +30,5 @@ - "referee": "^1.2.0", - "sinon": "^1.17.4" - }, -- "main": "./src/lolex-src.js" -+ "main": "./lolex.js" - } diff -Nru node-lolex-1.5.1/debian/patches/series node-lolex-2.2.0/debian/patches/series --- node-lolex-1.5.1/debian/patches/series 2016-10-12 11:44:44.000000000 +0000 +++ node-lolex-2.2.0/debian/patches/series 1970-01-01 00:00:00.000000000 +0000 @@ -1 +0,0 @@ -fix-package-json.patch diff -Nru node-lolex-1.5.1/debian/rules node-lolex-2.2.0/debian/rules --- node-lolex-1.5.1/debian/rules 2016-10-12 11:44:44.000000000 +0000 +++ node-lolex-2.2.0/debian/rules 2018-02-02 15:27:19.000000000 +0000 @@ -3,13 +3,15 @@ # Uncomment this to turn on verbose mode. #export DH_VERBOSE=1 +export NODE_PATH=debian/node_modules %: dh $@ #override_dh_auto_build: -#override_dh_auto_test: +override_dh_auto_test: + mocha -R spec override_dh_installchangelogs: dh_installchangelogs -k History.md diff -Nru node-lolex-1.5.1/debian/tests/control node-lolex-2.2.0/debian/tests/control --- node-lolex-1.5.1/debian/tests/control 2016-10-12 11:44:44.000000000 +0000 +++ node-lolex-2.2.0/debian/tests/control 2018-02-10 18:40:08.000000000 +0000 @@ -1,2 +1,5 @@ Tests: require Depends: node-lolex + +Test-Command: NODE_PATH=debian/node_modules mocha -R spec +Depends: @, @builddeps@ diff -Nru node-lolex-1.5.1/.eslintrc node-lolex-2.2.0/.eslintrc --- node-lolex-1.5.1/.eslintrc 2016-07-26 15:17:13.000000000 +0000 +++ node-lolex-2.2.0/.eslintrc 1970-01-01 00:00:00.000000000 +0000 @@ -1,172 +0,0 @@ -{ - "ecmaFeatures": {}, - "env": { - "browser": true, - "node": true - }, - "rules": { - "no-alert": 2, - "no-array-constructor": 2, - "no-bitwise": 2, - "no-caller": 2, - "no-catch-shadow": 2, - "no-cond-assign": 2, - "no-console": 2, - "no-constant-condition": 2, - "no-continue": 2, - "no-control-regex": 2, - "no-debugger": 2, - "no-delete-var": 2, - "no-div-regex": 0, - "no-dupe-keys": 2, - "no-dupe-args": 2, - "no-duplicate-case": 2, - "no-else-return": 2, - "no-empty": 2, - "no-empty-character-class": 2, - "no-eq-null": 0, - "no-eval": 2, - "no-ex-assign": 2, - "no-extend-native": 2, - "no-extra-bind": 2, - "no-extra-boolean-cast": 2, - "no-extra-parens": [2, "functions"], - "no-extra-semi": 2, - "no-fallthrough": 2, - "no-floating-decimal": 0, - "no-func-assign": 2, - "no-implied-eval": 2, - "no-inline-comments": 0, - "no-inner-declarations": [2, "functions"], - "no-invalid-regexp": 2, - "no-irregular-whitespace": 2, - "no-iterator": 2, - "no-label-var": 2, - "no-labels": 2, - "no-lone-blocks": 2, - "no-lonely-if": 0, - "no-loop-func": 2, - "no-mixed-requires": [0, false], - "no-mixed-spaces-and-tabs": [2, false], - "linebreak-style": [0, "unix"], - "no-multi-spaces": 2, - "no-multi-str": 2, - "no-multiple-empty-lines": [2, {"max": 2}], - "no-negated-in-lhs": 2, - "no-nested-ternary": 2, - "no-new": 2, - "no-new-func": 2, - "no-new-object": 2, - "no-new-require": 0, - "no-new-wrappers": 2, - "no-obj-calls": 2, - "no-octal": 2, - "no-octal-escape": 2, - "no-param-reassign": 0, - "no-path-concat": 0, - "no-plusplus": 1, - "no-process-env": 0, - "no-process-exit": 2, - "no-proto": 2, - "no-redeclare": 2, - "no-regex-spaces": 2, - "no-reserved-keys": 0, - "no-restricted-modules": 0, - "no-return-assign": 2, - "no-script-url": 2, - "no-self-compare": 0, - "no-sequences": 2, - "no-shadow-restricted-names": 2, - "no-space-before-semi": 0, - "no-spaced-func": 2, - "no-sparse-arrays": 2, - "no-sync": 0, - "no-ternary": 0, - "no-trailing-spaces": 2, - "no-this-before-super": 0, - "no-throw-literal": 0, - "no-undef": 2, - "no-undef-init": 2, - "no-undefined": 0, - "no-unexpected-multiline": 0, - "no-underscore-dangle": 2, - "no-unneeded-ternary": 0, - "no-unreachable": 2, - "no-unused-expressions": 2, - "no-unused-vars": [2, {"vars": "all", "args": "after-used"}], - "no-use-before-define": 2, - "no-void": 0, - "no-var": 0, - "prefer-const": 0, - "no-warning-comments": [0, { "terms": ["todo", "fixme", "xxx"], "location": "start" }], - "no-with": 2, - - "array-bracket-spacing": [2, "never"], - "accessor-pairs": 2, - "block-scoped-var": 0, - "brace-style": [0, "1tbs"], - "callback-return": 0, - "camelcase": 2, - "comma-dangle": [2, "never"], - "comma-spacing": 2, - "comma-style": 2, - "complexity": [0, 11], - "computed-property-spacing": [0, "never"], - "consistent-return": 2, - "consistent-this": [0, "that"], - "constructor-super": 0, - "curly": [2, "all"], - "default-case": 1, - "dot-location": 0, - "dot-notation": [2, { "allowKeywords": true }], - "eol-last": 2, - "eqeqeq": [2, "allow-null"], - "func-names": 0, - "func-style": [0, "declaration"], - "generator-star": 0, - "generator-star-spacing": 0, - "guard-for-in": 2, - "handle-callback-err": 0, - "indent": [2, 4, {"SwitchCase": 1}], - "init-declarations": 0, - "key-spacing": [2, { "beforeColon": false, "afterColon": true }], - "lines-around-comment": 0, - "max-depth": [0, 4], - "max-len": [2, 120, 4], - "max-nested-callbacks": [1, 3], - "max-params": [0, 3], - "max-statements": [0, 10], - "new-cap": 2, - "new-parens": 2, - "newline-after-var": 0, - "object-curly-spacing": [0, "never"], - "object-shorthand": 0, - "operator-assignment": [0, "always"], - "operator-linebreak": 0, - "padded-blocks": 0, - "quote-props": 0, - "quotes": [2, "double"], - "radix": 0, - "require-yield": 0, - "semi": 2, - "semi-spacing": [2, {"before": false, "after": true}], - "sort-vars": 0, - "keyword-spacing": [ "error", { "after": true} ], - "space-before-blocks": [2, "always"], - "space-before-function-paren": [2, {"anonymous": "always", "named": "never"}], - "space-before-function-parentheses": [0, "always"], - "space-in-brackets": [0, "never"], - "space-in-parens": [0, "never"], - "space-infix-ops": 2, - "space-unary-ops": [2, { "words": true, "nonwords": false }], - "spaced-comment": 0, - "spaced-line-comment": [0, "always"], - "use-isnan": 2, - "valid-jsdoc": 0, - "valid-typeof": 2, - "vars-on-top": 0, - "wrap-iife": 0, - "wrap-regex": 0, - "yoda": [2, "never"] - } -} diff -Nru node-lolex-1.5.1/.gitignore node-lolex-2.2.0/.gitignore --- node-lolex-1.5.1/.gitignore 2016-07-26 15:17:13.000000000 +0000 +++ node-lolex-2.2.0/.gitignore 2017-11-07 16:28:37.000000000 +0000 @@ -1 +1,3 @@ /node_modules +.DS_Store +.idea diff -Nru node-lolex-1.5.1/History.md node-lolex-2.2.0/History.md --- node-lolex-1.5.1/History.md 2016-07-26 15:17:13.000000000 +0000 +++ node-lolex-2.2.0/History.md 2017-11-07 16:28:37.000000000 +0000 @@ -1,3 +1,58 @@ + +v2.2.0 / 2017-11-07 +================== + + * Add support for requestAnimationFrame + * fix negative timeout bug + +v2.1.3 / 2017-10-03 +================== + + * add module entry point (#133) + +v2.1.2 / 2017-07-25 +================== + + * - does not fake process.nextTick by default - added .idea folder to .gitignore - fixed documentation - added clock teardowns in tests + * overflowing the timer correctly (issue #67) + +v2.1.1 / 2017-07-19 +================== + + * support passing parameters in nextTick (fixes #122) + +v2.1.0 / 2017-07-18 +================== + + * Throw error on incorrect install use (#112) + * Add support for process.nextTick + * lolex can now attach itself to the system timers and automatically ad… (#102) + * update hrtime when an interval ticks + +v2.0.0 / 2017-07-13 +================== + + * New install() signature + * Add support for performance.now (#106) + * Fix issue with tick(): setSystemClock then throw + * Update old dependencies + * Added support to automatically increment time (#85) + * Changed internal uninstall method signature + +v1.6.0 / 2017-02-25 +=================== + + * Use common Sinon.JS eslint config + * Allow install to be called with date object + * Remove wrapper function + * Fixed typo in clock.runAll error + +v1.5.2 / 2016-11-10 +=================== + + * Upgrade mocha to latest + * Only overwrite globals when running in IE + 1.5.1 / 2016-07-26 ================== diff -Nru node-lolex-1.5.1/lolex.js node-lolex-2.2.0/lolex.js --- node-lolex-1.5.1/lolex.js 2016-07-26 15:17:13.000000000 +0000 +++ node-lolex-2.2.0/lolex.js 2017-11-07 16:28:37.000000000 +0000 @@ -1,660 +1,759 @@ (function(f){if(typeof exports==="object"&&typeof module!=="undefined"){module.exports=f()}else if(typeof define==="function"&&define.amd){define([],f)}else{var g;if(typeof window!=="undefined"){g=window}else if(typeof global!=="undefined"){g=global}else if(typeof self!=="undefined"){g=self}else{g=this}g.lolex = f()}})(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o -1; +var maxTimeout = Math.pow(2, 31) - 1; //see https://heycam.github.io/webidl/#abstract-opdef-converttoint + +// Make properties writable in IE, as per +// http://www.adequatelygood.com/Replacing-setTimeout-Globally.html +if (isRunningInIE) { global.setTimeout = global.setTimeout; global.clearTimeout = global.clearTimeout; global.setInterval = global.setInterval; global.clearInterval = global.clearInterval; global.Date = global.Date; +} + +// setImmediate is not a standard function +// avoid adding the prop to the window object if not present +if (global.setImmediate !== undefined) { + global.setImmediate = global.setImmediate; + global.clearImmediate = global.clearImmediate; +} + +// node expects setTimeout/setInterval to return a fn object w/ .ref()/.unref() +// browsers, a number. +// see https://github.com/cjohansen/Sinon.JS/pull/436 + +var NOOP = function () { return undefined; }; +var timeoutResult = setTimeout(NOOP, 0); +var addTimerReturnsObject = typeof timeoutResult === "object"; +var hrtimePresent = (global.process && typeof global.process.hrtime === "function"); +var nextTickPresent = (global.process && typeof global.process.nextTick === "function"); +var performancePresent = (global.performance && typeof global.performance.now === "function"); - // setImmediate is not a standard function - // avoid adding the prop to the window object if not present - if (global.setImmediate !== undefined) { - global.setImmediate = global.setImmediate; - global.clearImmediate = global.clearImmediate; +clearTimeout(timeoutResult); + +var NativeDate = Date; +var uniqueTimerId = 1; + +/** + * Parse strings like "01:10:00" (meaning 1 hour, 10 minutes, 0 seconds) into + * number of milliseconds. This is used to support human-readable strings passed + * to clock.tick() + */ +function parseTime(str) { + if (!str) { + return 0; } - // node expects setTimeout/setInterval to return a fn object w/ .ref()/.unref() - // browsers, a number. - // see https://github.com/cjohansen/Sinon.JS/pull/436 + var strings = str.split(":"); + var l = strings.length; + var i = l; + var ms = 0; + var parsed; - var NOOP = function () { return undefined; }; - var timeoutResult = setTimeout(NOOP, 0); - var addTimerReturnsObject = typeof timeoutResult === "object"; - var hrtimePresent = (global.process && typeof global.process.hrtime === "function"); - clearTimeout(timeoutResult); + if (l > 3 || !/^(\d\d:){0,2}\d\d?$/.test(str)) { + throw new Error("tick only understands numbers, 'm:s' and 'h:m:s'. Each part must be two digits"); + } - var NativeDate = Date; - var uniqueTimerId = 1; + while (i--) { + parsed = parseInt(strings[i], 10); - /** - * Parse strings like "01:10:00" (meaning 1 hour, 10 minutes, 0 seconds) into - * number of milliseconds. This is used to support human-readable strings passed - * to clock.tick() - */ - function parseTime(str) { - if (!str) { - return 0; + if (parsed >= 60) { + throw new Error("Invalid time " + str); } - var strings = str.split(":"); - var l = strings.length, i = l; - var ms = 0, parsed; + ms += parsed * Math.pow(60, (l - i - 1)); + } - if (l > 3 || !/^(\d\d:){0,2}\d\d?$/.test(str)) { - throw new Error("tick only understands numbers, 'm:s' and 'h:m:s'. Each part must be two digits"); - } + return ms * 1000; +} - while (i--) { - parsed = parseInt(strings[i], 10); +/** + * Floor function that also works for negative numbers + */ +function fixedFloor(n) { + return (n >= 0 ? Math.floor(n) : Math.ceil(n)); +} - if (parsed >= 60) { - throw new Error("Invalid time " + str); - } +/** + * % operator that also works for negative numbers + */ +function fixedModulo(n, m) { + return ((n % m) + m) % m; +} - ms += parsed * Math.pow(60, (l - i - 1)); - } +/** + * Used to grok the `now` parameter to createClock. + * @param epoch {Date|number} the system time + */ +function getEpoch(epoch) { + if (!epoch) { return 0; } + if (typeof epoch.getTime === "function") { return epoch.getTime(); } + if (typeof epoch === "number") { return epoch; } + throw new TypeError("now should be milliseconds since UNIX epoch"); +} - return ms * 1000; - } +function inRange(from, to, timer) { + return timer && timer.callAt >= from && timer.callAt <= to; +} - /** - * Floor function that also works for negative numbers - */ - function fixedFloor(n) { - return (n >= 0 ? Math.floor(n) : Math.ceil(n)); +function mirrorDateProperties(target, source) { + var prop; + for (prop in source) { + if (source.hasOwnProperty(prop)) { + target[prop] = source[prop]; + } } - /** - * % operator that also works for negative numbers - */ - function fixedModulo(n, m) { - return ((n % m) + m) % m; + // set special now implementation + if (source.now) { + target.now = function now() { + return target.clock.now; + }; + } else { + delete target.now; } - /** - * Used to grok the `now` parameter to createClock. - */ - function getEpoch(epoch) { - if (!epoch) { return 0; } - if (typeof epoch.getTime === "function") { return epoch.getTime(); } - if (typeof epoch === "number") { return epoch; } - throw new TypeError("now should be milliseconds since UNIX epoch"); + // set special toSource implementation + if (source.toSource) { + target.toSource = function toSource() { + return source.toSource(); + }; + } else { + delete target.toSource; } - function inRange(from, to, timer) { - return timer && timer.callAt >= from && timer.callAt <= to; - } + // set special toString implementation + target.toString = function toString() { + return source.toString(); + }; - function mirrorDateProperties(target, source) { - var prop; - for (prop in source) { - if (source.hasOwnProperty(prop)) { - target[prop] = source[prop]; - } - } + target.prototype = source.prototype; + target.parse = source.parse; + target.UTC = source.UTC; + target.prototype.toUTCString = source.prototype.toUTCString; - // set special now implementation - if (source.now) { - target.now = function now() { - return target.clock.now; - }; - } else { - delete target.now; - } + return target; +} - // set special toSource implementation - if (source.toSource) { - target.toSource = function toSource() { - return source.toSource(); - }; - } else { - delete target.toSource; +function createDate() { + function ClockDate(year, month, date, hour, minute, second, ms) { + // Defensive and verbose to avoid potential harm in passing + // explicit undefined when user does not pass argument + switch (arguments.length) { + case 0: + return new NativeDate(ClockDate.clock.now); + case 1: + return new NativeDate(year); + case 2: + return new NativeDate(year, month); + case 3: + return new NativeDate(year, month, date); + case 4: + return new NativeDate(year, month, date, hour); + case 5: + return new NativeDate(year, month, date, hour, minute); + case 6: + return new NativeDate(year, month, date, hour, minute, second); + default: + return new NativeDate(year, month, date, hour, minute, second, ms); } + } - // set special toString implementation - target.toString = function toString() { - return source.toString(); - }; + return mirrorDateProperties(ClockDate, NativeDate); +} - target.prototype = source.prototype; - target.parse = source.parse; - target.UTC = source.UTC; - target.prototype.toUTCString = source.prototype.toUTCString; - return target; +function enqueueJob(clock, job) { + // enqueues a microtick-deferred task - ecma262/#sec-enqueuejob + if (!clock.jobs) { + clock.jobs = []; } + clock.jobs.push(job); +} - function createDate() { - function ClockDate(year, month, date, hour, minute, second, ms) { - // Defensive and verbose to avoid potential harm in passing - // explicit undefined when user does not pass argument - switch (arguments.length) { - case 0: - return new NativeDate(ClockDate.clock.now); - case 1: - return new NativeDate(year); - case 2: - return new NativeDate(year, month); - case 3: - return new NativeDate(year, month, date); - case 4: - return new NativeDate(year, month, date, hour); - case 5: - return new NativeDate(year, month, date, hour, minute); - case 6: - return new NativeDate(year, month, date, hour, minute, second); - default: - return new NativeDate(year, month, date, hour, minute, second, ms); - } - } +function runJobs(clock) { + // runs all microtick-deferred tasks - ecma262/#sec-runjobs + if (!clock.jobs) { + return; + } + for (var i = 0; i < clock.jobs.length; i++) { + var job = clock.jobs[i]; + job.func.apply(null, job.args); + } + clock.jobs = []; +} - return mirrorDateProperties(ClockDate, NativeDate); +function addTimer(clock, timer) { + if (timer.func === undefined) { + throw new Error("Callback must be provided to timer calls"); } - function addTimer(clock, timer) { - if (timer.func === undefined) { - throw new Error("Callback must be provided to timer calls"); - } + timer.type = timer.immediate ? "Immediate" : "Timeout"; - if (!clock.timers) { - clock.timers = {}; - } + if (timer.hasOwnProperty("delay")) { + timer.delay = timer.delay > maxTimeout ? 1 : timer.delay; + timer.delay = Math.max(0, timer.delay); + } - timer.id = uniqueTimerId++; - timer.createdAt = clock.now; - timer.callAt = clock.now + (timer.delay || (clock.duringTick ? 1 : 0)); + if (timer.hasOwnProperty("interval")) { + timer.type = "Interval"; + timer.interval = timer.interval > maxTimeout ? 1 : timer.interval; + } - clock.timers[timer.id] = timer; + if (timer.hasOwnProperty("animation")) { + timer.type = "AnimationFrame"; + timer.animation = true; + } - if (addTimerReturnsObject) { - return { - id: timer.id, - ref: NOOP, - unref: NOOP - }; - } + if (!clock.timers) { + clock.timers = {}; + } - return timer.id; + timer.id = uniqueTimerId++; + timer.createdAt = clock.now; + timer.callAt = clock.now + (parseInt(timer.delay) || (clock.duringTick ? 1 : 0)); + + clock.timers[timer.id] = timer; + + if (addTimerReturnsObject) { + return { + id: timer.id, + ref: NOOP, + unref: NOOP + }; } + return timer.id; +} - /* eslint consistent-return: "off" */ - function compareTimers(a, b) { - // Sort first by absolute timing - if (a.callAt < b.callAt) { - return -1; - } - if (a.callAt > b.callAt) { - return 1; - } - // Sort next by immediate, immediate timers take precedence - if (a.immediate && !b.immediate) { - return -1; - } - if (!a.immediate && b.immediate) { - return 1; - } +/* eslint consistent-return: "off" */ +function compareTimers(a, b) { + // Sort first by absolute timing + if (a.callAt < b.callAt) { + return -1; + } + if (a.callAt > b.callAt) { + return 1; + } - // Sort next by creation time, earlier-created timers take precedence - if (a.createdAt < b.createdAt) { - return -1; - } - if (a.createdAt > b.createdAt) { - return 1; - } + // Sort next by immediate, immediate timers take precedence + if (a.immediate && !b.immediate) { + return -1; + } + if (!a.immediate && b.immediate) { + return 1; + } - // Sort next by id, lower-id timers take precedence - if (a.id < b.id) { - return -1; - } - if (a.id > b.id) { - return 1; - } + // Sort next by creation time, earlier-created timers take precedence + if (a.createdAt < b.createdAt) { + return -1; + } + if (a.createdAt > b.createdAt) { + return 1; + } - // As timer ids are unique, no fallback `0` is necessary + // Sort next by id, lower-id timers take precedence + if (a.id < b.id) { + return -1; + } + if (a.id > b.id) { + return 1; } - function firstTimerInRange(clock, from, to) { - var timers = clock.timers, - timer = null, - id, - isInRange; + // As timer ids are unique, no fallback `0` is necessary +} - for (id in timers) { - if (timers.hasOwnProperty(id)) { - isInRange = inRange(from, to, timers[id]); +function firstTimerInRange(clock, from, to) { + var timers = clock.timers; + var timer = null; + var id, isInRange; - if (isInRange && (!timer || compareTimers(timer, timers[id]) === 1)) { - timer = timers[id]; - } + for (id in timers) { + if (timers.hasOwnProperty(id)) { + isInRange = inRange(from, to, timers[id]); + + if (isInRange && (!timer || compareTimers(timer, timers[id]) === 1)) { + timer = timers[id]; } } - - return timer; } - function firstTimer(clock) { - var timers = clock.timers, - timer = null, - id; - - for (id in timers) { - if (timers.hasOwnProperty(id)) { - if (!timer || compareTimers(timer, timers[id]) === 1) { - timer = timers[id]; - } - } - } + return timer; +} - return timer; - } +function firstTimer(clock) { + var timers = clock.timers; + var timer = null; + var id; - function lastTimer(clock) { - var timers = clock.timers, - timer = null, - id; - - for (id in timers) { - if (timers.hasOwnProperty(id)) { - if (!timer || compareTimers(timer, timers[id]) === -1) { - timer = timers[id]; - } + for (id in timers) { + if (timers.hasOwnProperty(id)) { + if (!timer || compareTimers(timer, timers[id]) === 1) { + timer = timers[id]; } } - - return timer; } - function callTimer(clock, timer) { - var exception; + return timer; +} - if (typeof timer.interval === "number") { - clock.timers[timer.id].callAt += timer.interval; - } else { - delete clock.timers[timer.id]; - } +function lastTimer(clock) { + var timers = clock.timers; + var timer = null; + var id; - try { - if (typeof timer.func === "function") { - timer.func.apply(null, timer.args); - } else { - /* eslint no-eval: "off" */ - eval(timer.func); + for (id in timers) { + if (timers.hasOwnProperty(id)) { + if (!timer || compareTimers(timer, timers[id]) === -1) { + timer = timers[id]; } - } catch (e) { - exception = e; } + } - if (!clock.timers[timer.id]) { - if (exception) { - throw exception; - } - return; - } + return timer; +} - if (exception) { - throw exception; - } +function callTimer(clock, timer) { + if (typeof timer.interval === "number") { + clock.timers[timer.id].callAt += timer.interval; + } else { + delete clock.timers[timer.id]; } - function timerType(timer) { - if (timer.immediate) { - return "Immediate"; - } - if (timer.interval !== undefined) { - return "Interval"; - } - return "Timeout"; + if (typeof timer.func === "function") { + timer.func.apply(null, timer.args); + } else { + /* eslint no-eval: "off" */ + eval(timer.func); } +} - function clearTimer(clock, timerId, ttype) { - if (!timerId) { - // null appears to be allowed in most browsers, and appears to be - // relied upon by some libraries, like Bootstrap carousel - return; - } +function clearTimer(clock, timerId, ttype) { + if (!timerId) { + // null appears to be allowed in most browsers, and appears to be + // relied upon by some libraries, like Bootstrap carousel + return; + } - if (!clock.timers) { - clock.timers = []; - } + if (!clock.timers) { + clock.timers = []; + } - // in Node, timerId is an object with .ref()/.unref(), and - // its .id field is the actual timer id. - if (typeof timerId === "object") { - timerId = timerId.id; - } + // in Node, timerId is an object with .ref()/.unref(), and + // its .id field is the actual timer id. + if (typeof timerId === "object") { + timerId = timerId.id; + } - if (clock.timers.hasOwnProperty(timerId)) { - // check that the ID matches a timer of the correct type - var timer = clock.timers[timerId]; - if (timerType(timer) === ttype) { - delete clock.timers[timerId]; + if (clock.timers.hasOwnProperty(timerId)) { + // check that the ID matches a timer of the correct type + var timer = clock.timers[timerId]; + if (timer.type === ttype) { + delete clock.timers[timerId]; + } else { + var clear = ttype === "AnimationFrame" ? "cancelAnimationFrame" : "clear" + ttype; + var schedule = timer.type === "AnimationFrame" ? "requestAnimationFrame" : "set" + timer.type; + throw new Error("Cannot clear timer: timer created with " + schedule + + "() but cleared with " + clear + "()"); + } + } +} + +function uninstall(clock, target, config) { + var method, + i, + l; + var installedHrTime = "_hrtime"; + var installedNextTick = "_nextTick"; + + for (i = 0, l = clock.methods.length; i < l; i++) { + method = clock.methods[i]; + if (method === "hrtime" && target.process) { + target.process.hrtime = clock[installedHrTime]; + } else if (method === "nextTick" && target.process) { + target.process.nextTick = clock[installedNextTick]; + } else { + if (target[method] && target[method].hadOwnProperty) { + target[method] = clock["_" + method]; + if (method === "clearInterval" && config.shouldAdvanceTime === true) { + target[method](clock.attachedInterval); + } } else { - throw new Error("Cannot clear timer: timer created with set" + timerType(timer) - + "() but cleared with clear" + ttype + "()"); + try { + delete target[method]; + } catch (ignore) { /* eslint empty-block: "off" */ } } } } - function uninstall(clock, target) { - var method, - i, - l; - var installedHrTime = "_hrtime"; + // Prevent multiple executions which will completely remove these props + clock.methods = []; +} - for (i = 0, l = clock.methods.length; i < l; i++) { - method = clock.methods[i]; - if (method === "hrtime" && target.process) { - target.process.hrtime = clock[installedHrTime]; - } else { - if (target[method] && target[method].hadOwnProperty) { - target[method] = clock["_" + method]; - } else { - try { - delete target[method]; - } catch (ignore) { /* eslint empty-block: "off" */ } - } +function hijackMethod(target, method, clock) { + var prop; + clock[method].hadOwnProperty = Object.prototype.hasOwnProperty.call(target, method); + clock["_" + method] = target[method]; + + if (method === "Date") { + var date = mirrorDateProperties(clock[method], target[method]); + target[method] = date; + } else { + target[method] = function () { + return clock[method].apply(clock, arguments); + }; + + for (prop in clock[method]) { + if (clock[method].hasOwnProperty(prop)) { + target[method][prop] = clock[method][prop]; } } - - // Prevent multiple executions which will completely remove these props - clock.methods = []; } - function hijackMethod(target, method, clock) { - var prop; + target[method].clock = clock; +} - clock[method].hadOwnProperty = Object.prototype.hasOwnProperty.call(target, method); - clock["_" + method] = target[method]; +function doIntervalTick(clock, advanceTimeDelta) { + clock.tick(advanceTimeDelta); +} - if (method === "Date") { - var date = mirrorDateProperties(clock[method], target[method]); - target[method] = date; - } else { - target[method] = function () { - return clock[method].apply(clock, arguments); - }; - - for (prop in clock[method]) { - if (clock[method].hasOwnProperty(prop)) { - target[method][prop] = clock[method][prop]; - } - } - } +var timers = { + setTimeout: setTimeout, + clearTimeout: clearTimeout, + setImmediate: global.setImmediate, + clearImmediate: global.clearImmediate, + setInterval: setInterval, + clearInterval: clearInterval, + requestAnimationFrame: global.requestAnimationFrame, + cancelAnimationFrame: global.cancelAnimationFrame, + Date: Date +}; - target[method].clock = clock; - } +if (hrtimePresent) { + timers.hrtime = global.process.hrtime; +} - var timers = { - setTimeout: setTimeout, - clearTimeout: clearTimeout, - setImmediate: global.setImmediate, - clearImmediate: global.clearImmediate, - setInterval: setInterval, - clearInterval: clearInterval, - Date: Date - }; +if (nextTickPresent) { + timers.nextTick = global.process.nextTick; +} - if (hrtimePresent) { - timers.hrtime = global.process.hrtime; - } +if (performancePresent) { + timers.performance = global.performance; +} - var keys = Object.keys || function (obj) { - var ks = [], - key; +var keys = Object.keys || function (obj) { + var ks = []; + var key; - for (key in obj) { - if (obj.hasOwnProperty(key)) { - ks.push(key); - } + for (key in obj) { + if (obj.hasOwnProperty(key)) { + ks.push(key); } + } + + return ks; +}; - return ks; +exports.timers = timers; + +/** + * @param start {Date|number} the system time + * @param loopLimit {number} maximum number of timers that will be run when calling runAll() + */ +function createClock(start, loopLimit) { + start = start || 0; + loopLimit = loopLimit || 1000; + + var clock = { + now: getEpoch(start), + hrNow: 0, + timeouts: {}, + Date: createDate(), + loopLimit: loopLimit }; - exports.timers = timers; + clock.Date.clock = clock; - function createClock(now, loopLimit) { - loopLimit = loopLimit || 1000; + function getTimeToNextFrame() { + return 16 - ((clock.now - start) % 16); + } - var clock = { - now: getEpoch(now), - hrNow: 0, - timeouts: {}, - Date: createDate(), - loopLimit: loopLimit - }; + clock.setTimeout = function setTimeout(func, timeout) { + return addTimer(clock, { + func: func, + args: Array.prototype.slice.call(arguments, 2), + delay: timeout + }); + }; - clock.Date.clock = clock; + clock.clearTimeout = function clearTimeout(timerId) { + return clearTimer(clock, timerId, "Timeout"); + }; + clock.nextTick = function nextTick(func) { + return enqueueJob(clock, { + func: func, + args: Array.prototype.slice.call(arguments, 1) + }); + }; + clock.setInterval = function setInterval(func, timeout) { + return addTimer(clock, { + func: func, + args: Array.prototype.slice.call(arguments, 2), + delay: timeout, + interval: timeout + }); + }; - clock.setTimeout = function setTimeout(func, timeout) { - return addTimer(clock, { - func: func, - args: Array.prototype.slice.call(arguments, 2), - delay: timeout - }); - }; + clock.clearInterval = function clearInterval(timerId) { + return clearTimer(clock, timerId, "Interval"); + }; - clock.clearTimeout = function clearTimeout(timerId) { - return clearTimer(clock, timerId, "Timeout"); - }; + clock.setImmediate = function setImmediate(func) { + return addTimer(clock, { + func: func, + args: Array.prototype.slice.call(arguments, 1), + immediate: true + }); + }; - clock.setInterval = function setInterval(func, timeout) { - return addTimer(clock, { - func: func, - args: Array.prototype.slice.call(arguments, 2), - delay: timeout, - interval: timeout - }); - }; + clock.clearImmediate = function clearImmediate(timerId) { + return clearTimer(clock, timerId, "Immediate"); + }; - clock.clearInterval = function clearInterval(timerId) { - return clearTimer(clock, timerId, "Interval"); - }; + clock.requestAnimationFrame = function requestAnimationFrame(func) { + var result = addTimer(clock, { + func: func, + delay: getTimeToNextFrame(), + args: [clock.now + getTimeToNextFrame()], + animation: true + }); - clock.setImmediate = function setImmediate(func) { - return addTimer(clock, { - func: func, - args: Array.prototype.slice.call(arguments, 1), - immediate: true - }); - }; + return result.id || result; + }; - clock.clearImmediate = function clearImmediate(timerId) { - return clearTimer(clock, timerId, "Immediate"); - }; + clock.cancelAnimationFrame = function cancelAnimationFrame(timerId) { + return clearTimer(clock, timerId, "AnimationFrame"); + }; + + function updateHrTime(newNow) { + clock.hrNow += (newNow - clock.now); + } - clock.tick = function tick(ms) { - ms = typeof ms === "number" ? ms : parseTime(ms); - var tickFrom = clock.now, tickTo = clock.now + ms, previous = clock.now; - var timer = firstTimerInRange(clock, tickFrom, tickTo); - var oldNow; - - clock.duringTick = true; - - function updateHrTime(newNow) { - clock.hrNow += (newNow - clock.now); - } - - var firstException; - while (timer && tickFrom <= tickTo) { - if (clock.timers[timer.id]) { - updateHrTime(timer.callAt); - tickFrom = timer.callAt; - clock.now = timer.callAt; - try { - oldNow = clock.now; - callTimer(clock, timer); - // compensate for any setSystemTime() call during timer callback - if (oldNow !== clock.now) { - tickFrom += clock.now - oldNow; - tickTo += clock.now - oldNow; - previous += clock.now - oldNow; - } - } catch (e) { - firstException = firstException || e; - } + clock.tick = function tick(ms) { + ms = typeof ms === "number" ? ms : parseTime(ms); + var tickFrom = clock.now; + var tickTo = clock.now + ms; + var previous = clock.now; + var timer = firstTimerInRange(clock, tickFrom, tickTo); + var oldNow, firstException; + + clock.duringTick = true; + runJobs(clock); + + while (timer && tickFrom <= tickTo) { + if (clock.timers[timer.id]) { + updateHrTime(timer.callAt); + tickFrom = timer.callAt; + clock.now = timer.callAt; + try { + runJobs(clock); + oldNow = clock.now; + callTimer(clock, timer); + } catch (e) { + firstException = firstException || e; } - timer = firstTimerInRange(clock, previous, tickTo); - previous = tickFrom; + // compensate for any setSystemTime() call during timer callback + if (oldNow !== clock.now) { + tickFrom += clock.now - oldNow; + tickTo += clock.now - oldNow; + previous += clock.now - oldNow; + } } - clock.duringTick = false; - updateHrTime(tickTo); - clock.now = tickTo; + timer = firstTimerInRange(clock, previous, tickTo); + previous = tickFrom; + } - if (firstException) { - throw firstException; - } + runJobs(clock); + clock.duringTick = false; + updateHrTime(tickTo); + clock.now = tickTo; + if (firstException) { + throw firstException; + } + + return clock.now; + }; + + clock.next = function next() { + runJobs(clock); + var timer = firstTimer(clock); + if (!timer) { return clock.now; - }; + } + + clock.duringTick = true; + try { + updateHrTime(timer.callAt); + clock.now = timer.callAt; + callTimer(clock, timer); + runJobs(clock); + return clock.now; + } finally { + clock.duringTick = false; + } + }; - clock.next = function next() { - var timer = firstTimer(clock); - if (!timer) { + clock.runAll = function runAll() { + var numTimers, i; + runJobs(clock); + for (i = 0; i < clock.loopLimit; i++) { + if (!clock.timers) { return clock.now; } - clock.duringTick = true; - try { - clock.now = timer.callAt; - callTimer(clock, timer); + numTimers = keys(clock.timers).length; + if (numTimers === 0) { return clock.now; - } finally { - clock.duringTick = false; } - }; - - clock.runAll = function runAll() { - var numTimers, i; - for (i = 0; i < clock.loopLimit; i++) { - if (!clock.timers) { - return clock.now; - } - numTimers = Object.keys(clock.timers).length; - if (numTimers === 0) { - return clock.now; - } + clock.next(); + } - clock.next(); - } + throw new Error("Aborting after running " + clock.loopLimit + " timers, assuming an infinite loop!"); + }; - throw new Error("Aborting after running " + clock.loopLimit + "timers, assuming an infinite loop!"); - }; + clock.runToFrame = function runToFrame() { + return clock.tick(getTimeToNextFrame()); + }; - clock.runToLast = function runToLast() { - var timer = lastTimer(clock); - if (!timer) { - return clock.now; - } + clock.runToLast = function runToLast() { + var timer = lastTimer(clock); + if (!timer) { + runJobs(clock); + return clock.now; + } - return clock.tick(timer.callAt); - }; + return clock.tick(timer.callAt); + }; - clock.reset = function reset() { - clock.timers = {}; - }; + clock.reset = function reset() { + clock.timers = {}; + }; - clock.setSystemTime = function setSystemTime(now) { - // determine time difference - var newNow = getEpoch(now); - var difference = newNow - clock.now; - var id, timer; - - // update 'system clock' - clock.now = newNow; - - // update timers and intervals to keep them stable - for (id in clock.timers) { - if (clock.timers.hasOwnProperty(id)) { - timer = clock.timers[id]; - timer.createdAt += difference; - timer.callAt += difference; - } + clock.setSystemTime = function setSystemTime(systemTime) { + // determine time difference + var newNow = getEpoch(systemTime); + var difference = newNow - clock.now; + var id, timer; + + // update 'system clock' + clock.now = newNow; + + // update timers and intervals to keep them stable + for (id in clock.timers) { + if (clock.timers.hasOwnProperty(id)) { + timer = clock.timers[id]; + timer.createdAt += difference; + timer.callAt += difference; } - }; + } + }; - if (hrtimePresent) { - clock.hrtime = function (prev) { - if (Array.isArray(prev)) { - var oldSecs = (prev[0] + prev[1] / 1e9); - var newSecs = (clock.hrNow / 1000); - var difference = (newSecs - oldSecs); - var secs = fixedFloor(difference); - var nanosecs = fixedModulo(difference * 1e9, 1e9); - return [ - secs, - nanosecs - ]; - } + if (performancePresent) { + clock.performance = Object.create(global.performance); + clock.performance.now = function lolexNow() { + return clock.hrNow; + }; + } + if (hrtimePresent) { + clock.hrtime = function (prev) { + if (Array.isArray(prev)) { + var oldSecs = (prev[0] + prev[1] / 1e9); + var newSecs = (clock.hrNow / 1000); + var difference = (newSecs - oldSecs); + var secs = fixedFloor(difference); + var nanosecs = fixedModulo(difference * 1e9, 1e9); return [ - fixedFloor(clock.hrNow / 1000), - fixedModulo(clock.hrNow * 1e6, 1e9) + secs, + nanosecs ]; - }; - } - - return clock; + } + return [ + fixedFloor(clock.hrNow / 1000), + fixedModulo(clock.hrNow * 1e6, 1e9) + ]; + }; } - exports.createClock = createClock; - exports.install = function install(target, now, toFake, loopLimit) { - var i, - l; + return clock; +} +exports.createClock = createClock; - if (typeof target === "number") { - toFake = now; - now = target; - target = null; - } - - if (!target) { - target = global; - } - - var clock = createClock(now, loopLimit); +/** + * @param config {Object} optional config + * @param config.target {Object} the target to install timers in (default `window`) + * @param config.now {number|Date} a number (in milliseconds) or a Date object (default epoch) + * @param config.toFake {string[]} names of the methods that should be faked. + * @param config.loopLimit {number} the maximum number of timers that will be run when calling runAll() + * @param config.shouldAdvanceTime {Boolean} tells lolex to increment mocked time automatically (default false) + * @param config.advanceTimeDelta {Number} increment mocked time every <> ms (default: 20ms) + */ +exports.install = function install(config) { + if ( arguments.length > 1 || config instanceof Date || Array.isArray(config) || typeof config === "number") { + throw new TypeError("lolex.install called with " + String(config) + + " lolex 2.0+ requires an object parameter - see https://github.com/sinonjs/lolex"); + } + config = typeof config !== "undefined" ? config : {}; + config.shouldAdvanceTime = config.shouldAdvanceTime || false; + config.advanceTimeDelta = config.advanceTimeDelta || 20; + + var i, l; + var target = config.target || global; + var clock = createClock(config.now, config.loopLimit); - clock.uninstall = function () { - uninstall(clock, target); - }; + clock.uninstall = function () { + uninstall(clock, target, config); + }; - clock.methods = toFake || []; + clock.methods = config.toFake || []; - if (clock.methods.length === 0) { - clock.methods = keys(timers); - } + if (clock.methods.length === 0) { + // do not fake nextTick by default - GitHub#126 + clock.methods = keys(timers).filter(function (key) {return key !== "nextTick";}); + } - for (i = 0, l = clock.methods.length; i < l; i++) { - if (clock.methods[i] === "hrtime") { - if (target.process && typeof target.process.hrtime === "function") { - hijackMethod(target.process, clock.methods[i], clock); - } - } else { - hijackMethod(target, clock.methods[i], clock); + for (i = 0, l = clock.methods.length; i < l; i++) { + if (clock.methods[i] === "hrtime") { + if (target.process && typeof target.process.hrtime === "function") { + hijackMethod(target.process, clock.methods[i], clock); } + } else if (clock.methods[i] === "nextTick") { + if (target.process && typeof target.process.nextTick === "function") { + hijackMethod(target.process, clock.methods[i], clock); + } + } else { + if (clock.methods[i] === "setInterval" && config.shouldAdvanceTime === true) { + var intervalTick = doIntervalTick.bind(null, clock, config.advanceTimeDelta); + var intervalId = target[clock.methods[i]]( + intervalTick, + config.advanceTimeDelta); + clock.attachedInterval = intervalId; + } + hijackMethod(target, clock.methods[i], clock); } + } - return clock; - }; - -}(global || this)); + return clock; +}; }).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}) },{}]},{},[1])(1) diff -Nru node-lolex-1.5.1/package.json node-lolex-2.2.0/package.json --- node-lolex-1.5.1/package.json 2016-07-26 15:17:13.000000000 +0000 +++ node-lolex-2.2.0/package.json 2017-11-07 16:28:37.000000000 +0000 @@ -1,7 +1,7 @@ { "name": "lolex", "description": "Fake JavaScript timers", - "version": "1.5.1", + "version": "2.2.0", "homepage": "http://github.com/sinonjs/lolex", "author": "Christian Johansen", "repository": { @@ -20,15 +20,28 @@ "test-cloud": "mochify --wd", "test": "npm run lint && npm run test-node && npm run test-headless", "bundle": "browserify -s lolex -o lolex.js src/lolex-src.js", - "prepublish": "npm run bundle" + "prepublish": "npm run bundle", + "precommit": "run-p lint test-node" + }, + "lint-staged": { + "*.js": "eslint" }, "devDependencies": { - "eslint": "^3.0.1", - "browserify": "^13.0.1", - "mocha": "^2.5.3", - "mochify": "^2.18.0", + "browserify": "^14.4.0", + "eslint": "^4.2.0", + "eslint-config-sinon": "^1.0.3", + "eslint-plugin-mocha": "^4.8.0", + "husky": "^0.14.3", + "lint-staged": "^4.0.2", + "mocha": "^3.4.2", + "mochify": "^3.3.0", + "npm-run-all": "^4.0.2", "referee": "^1.2.0", - "sinon": "^1.17.4" + "sinon": "^2.3.7" + }, + "eslintConfig": { + "extends": "eslint-config-sinon" }, + "module": "./lolex.js", "main": "./src/lolex-src.js" } diff -Nru node-lolex-1.5.1/package-lock.json node-lolex-2.2.0/package-lock.json --- node-lolex-1.5.1/package-lock.json 1970-01-01 00:00:00.000000000 +0000 +++ node-lolex-2.2.0/package-lock.json 2017-11-07 16:28:37.000000000 +0000 @@ -0,0 +1,4434 @@ +{ + "name": "lolex", + "version": "2.2.0", + "lockfileVersion": 1, + "requires": true, + "dependencies": { + "JSONStream": { + "version": "1.3.1", + "resolved": "https://registry.npmjs.org/JSONStream/-/JSONStream-1.3.1.tgz", + "integrity": "sha1-cH92HgHa6eFvG8+TcDt4xwlmV5o=", + "dev": true, + "requires": { + "jsonparse": "1.3.1", + "through": "2.3.8" + } + }, + "acorn": { + "version": "4.0.13", + "resolved": "https://registry.npmjs.org/acorn/-/acorn-4.0.13.tgz", + "integrity": "sha1-EFSVrlNh1pe9GVyCUZLhrX8lN4c=", + "dev": true + }, + "acorn-jsx": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/acorn-jsx/-/acorn-jsx-3.0.1.tgz", + "integrity": "sha1-r9+UiPsezvyDSPb7IvRk4ypYs2s=", + "dev": true, + "requires": { + "acorn": "3.3.0" + }, + "dependencies": { + "acorn": { + "version": "3.3.0", + "resolved": "https://registry.npmjs.org/acorn/-/acorn-3.3.0.tgz", + "integrity": "sha1-ReN/s56No/JbruP/U2niu18iAXo=", + "dev": true + } + } + }, + "agent-base": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/agent-base/-/agent-base-2.1.1.tgz", + "integrity": "sha1-1t4Q1a9hMtW9aSQn1G/FOFOQlMc=", + "dev": true, + "requires": { + "extend": "3.0.1", + "semver": "5.0.3" + }, + "dependencies": { + "semver": { + "version": "5.0.3", + "resolved": "https://registry.npmjs.org/semver/-/semver-5.0.3.tgz", + "integrity": "sha1-d0Zt5YnNXTyV8TiqeLxWmjy10no=", + "dev": true + } + } + }, + "ajv": { + "version": "5.2.3", + "resolved": "https://registry.npmjs.org/ajv/-/ajv-5.2.3.tgz", + "integrity": "sha1-wG9Zh3jETGsWGrr+NGa4GtGBTtI=", + "dev": true, + "requires": { + "co": "4.6.0", + "fast-deep-equal": "1.0.0", + "json-schema-traverse": "0.3.1", + "json-stable-stringify": "1.0.1" + }, + "dependencies": { + "json-stable-stringify": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/json-stable-stringify/-/json-stable-stringify-1.0.1.tgz", + "integrity": "sha1-mnWdOcXy/1A/1TAGRu1EX4jE+a8=", + "dev": true, + "requires": { + "jsonify": "0.0.0" + } + } + } + }, + "ajv-keywords": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/ajv-keywords/-/ajv-keywords-2.1.0.tgz", + "integrity": "sha1-opbhf3v658HOT34N5T0pyzIWLfA=", + "dev": true + }, + "amdefine": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/amdefine/-/amdefine-1.0.1.tgz", + "integrity": "sha1-SlKCrBZHKek2Gbz9OtFR+BfOkfU=", + "dev": true + }, + "ansi-escapes": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/ansi-escapes/-/ansi-escapes-3.0.0.tgz", + "integrity": "sha512-O/klc27mWNUigtv0F8NJWbLF00OcegQalkqKURWdosW08YZKi4m6CnSUSvIZG1otNJbTWhN01Hhz389DW7mvDQ==", + "dev": true + }, + "ansi-regex": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-2.1.1.tgz", + "integrity": "sha1-w7M6te42DYbg5ijwRorn7yfWVN8=", + "dev": true + }, + "ansi-styles": { + "version": "2.2.1", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-2.2.1.tgz", + "integrity": "sha1-tDLdM1i2NM914eRmQ2gkBTPB3b4=", + "dev": true + }, + "ansi_up": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/ansi_up/-/ansi_up-1.3.0.tgz", + "integrity": "sha1-yclGv8C5u16qBgaEvyq6r+aLvUQ=", + "dev": true + }, + "anymatch": { + "version": "1.3.2", + "resolved": "https://registry.npmjs.org/anymatch/-/anymatch-1.3.2.tgz", + "integrity": "sha512-0XNayC8lTHQ2OI8aljNCN3sSx6hsr/1+rlcDAotXJR7C1oZZHCNsfpbKwMjRA3Uqb5tF1Rae2oloTr4xpq+WjA==", + "dev": true, + "requires": { + "micromatch": "2.3.11", + "normalize-path": "2.1.1" + }, + "dependencies": { + "normalize-path": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/normalize-path/-/normalize-path-2.1.1.tgz", + "integrity": "sha1-GrKLVW4Zg2Oowab35vogE3/mrtk=", + "dev": true, + "requires": { + "remove-trailing-separator": "1.1.0" + } + } + } + }, + "app-root-path": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/app-root-path/-/app-root-path-2.0.1.tgz", + "integrity": "sha1-zWLc+OT9WkF+/GZNLlsQZTxlG0Y=", + "dev": true + }, + "argparse": { + "version": "1.0.9", + "resolved": "https://registry.npmjs.org/argparse/-/argparse-1.0.9.tgz", + "integrity": "sha1-c9g7wmP4bpf4zE9rrhsOkKfSLIY=", + "dev": true, + "requires": { + "sprintf-js": "1.0.3" + } + }, + "arr-diff": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/arr-diff/-/arr-diff-2.0.0.tgz", + "integrity": "sha1-jzuCf5Vai9ZpaX5KQlasPOrjVs8=", + "dev": true, + "requires": { + "arr-flatten": "1.1.0" + } + }, + "arr-flatten": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/arr-flatten/-/arr-flatten-1.1.0.tgz", + "integrity": "sha512-L3hKV5R/p5o81R7O02IGnwpDmkp6E982XhtbuwSe3O4qOtMMMtodicASA1Cny2U+aCXcNpml+m4dPsvsJ3jatg==", + "dev": true + }, + "array-filter": { + "version": "0.0.1", + "resolved": "https://registry.npmjs.org/array-filter/-/array-filter-0.0.1.tgz", + "integrity": "sha1-fajPLiZijtcygDWB/SH2fKzS7uw=", + "dev": true + }, + "array-map": { + "version": "0.0.0", + "resolved": "https://registry.npmjs.org/array-map/-/array-map-0.0.0.tgz", + "integrity": "sha1-iKK6tz0c97zVwbEYoAP2b2ZfpmI=", + "dev": true + }, + "array-reduce": { + "version": "0.0.0", + "resolved": "https://registry.npmjs.org/array-reduce/-/array-reduce-0.0.0.tgz", + "integrity": "sha1-FziZ0//Rx9k4PkR5Ul2+J4yrXys=", + "dev": true + }, + "array-union": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/array-union/-/array-union-1.0.2.tgz", + "integrity": "sha1-mjRBDk9OPaI96jdb5b5w8kd47Dk=", + "dev": true, + "requires": { + "array-uniq": "1.0.3" + } + }, + "array-uniq": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/array-uniq/-/array-uniq-1.0.3.tgz", + "integrity": "sha1-r2rId6Jcx/dOBYiUdThY39sk/bY=", + "dev": true + }, + "array-unique": { + "version": "0.2.1", + "resolved": "https://registry.npmjs.org/array-unique/-/array-unique-0.2.1.tgz", + "integrity": "sha1-odl8yvy8JiXMcPrc6zalDFiwGlM=", + "dev": true + }, + "arrify": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/arrify/-/arrify-1.0.1.tgz", + "integrity": "sha1-iYUI2iIm84DfkEcoRWhJwVAaSw0=", + "dev": true + }, + "asn1.js": { + "version": "4.9.1", + "resolved": "https://registry.npmjs.org/asn1.js/-/asn1.js-4.9.1.tgz", + "integrity": "sha1-SLokC0WpKA6UdImQull9IWYX/UA=", + "dev": true, + "requires": { + "bn.js": "4.11.8", + "inherits": "2.0.3", + "minimalistic-assert": "1.0.0" + } + }, + "assert": { + "version": "1.4.1", + "resolved": "https://registry.npmjs.org/assert/-/assert-1.4.1.tgz", + "integrity": "sha1-mZEtWRg2tab1s0XA8H7vwI/GXZE=", + "dev": true, + "requires": { + "util": "0.10.3" + } + }, + "astw": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/astw/-/astw-2.2.0.tgz", + "integrity": "sha1-e9QXhNMkk5h66yOba04cV6hzuRc=", + "dev": true, + "requires": { + "acorn": "4.0.13" + } + }, + "async-each": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/async-each/-/async-each-1.0.1.tgz", + "integrity": "sha1-GdOGodntxufByF04iu28xW0zYC0=", + "dev": true + }, + "babel-code-frame": { + "version": "6.26.0", + "resolved": "https://registry.npmjs.org/babel-code-frame/-/babel-code-frame-6.26.0.tgz", + "integrity": "sha1-Y/1D99weO7fONZR9uP42mj9Yx0s=", + "dev": true, + "requires": { + "chalk": "1.1.3", + "esutils": "2.0.2", + "js-tokens": "3.0.2" + }, + "dependencies": { + "chalk": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-1.1.3.tgz", + "integrity": "sha1-qBFcVeSnAv5NFQq9OHKCKn4J/Jg=", + "dev": true, + "requires": { + "ansi-styles": "2.2.1", + "escape-string-regexp": "1.0.5", + "has-ansi": "2.0.0", + "strip-ansi": "3.0.1", + "supports-color": "2.0.0" + } + }, + "strip-ansi": { + "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.1.1" + } + } + } + }, + "balanced-match": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.0.tgz", + "integrity": "sha1-ibTRmasr7kneFk6gK4nORi1xt2c=", + "dev": true + }, + "bane": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/bane/-/bane-1.1.2.tgz", + "integrity": "sha1-vGQkjMgjFgx98/I4uH/mLEThB7k=", + "dev": true + }, + "base64-js": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/base64-js/-/base64-js-1.2.1.tgz", + "integrity": "sha512-dwVUVIXsBZXwTuwnXI9RK8sBmgq09NDHzyR9SAph9eqk76gKK2JSQmZARC2zRC81JC2QTtxD0ARU5qTS25gIGw==", + "dev": true + }, + "binary-extensions": { + "version": "1.10.0", + "resolved": "https://registry.npmjs.org/binary-extensions/-/binary-extensions-1.10.0.tgz", + "integrity": "sha1-muuabF6IY4qtFx4Wf1kAq+JINdA=", + "dev": true + }, + "bn.js": { + "version": "4.11.8", + "resolved": "https://registry.npmjs.org/bn.js/-/bn.js-4.11.8.tgz", + "integrity": "sha512-ItfYfPLkWHUjckQCk8xC+LwxgK8NYcXywGigJgSwOP8Y2iyWT4f2vsZnoOXTTbo+o5yXmIUJ4gn5538SO5S3gA==", + "dev": true + }, + "brace-expansion": { + "version": "1.1.8", + "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.8.tgz", + "integrity": "sha1-wHshHHyVLsH479Uad+8NHTmQopI=", + "dev": true, + "requires": { + "balanced-match": "1.0.0", + "concat-map": "0.0.1" + } + }, + "braces": { + "version": "1.8.5", + "resolved": "https://registry.npmjs.org/braces/-/braces-1.8.5.tgz", + "integrity": "sha1-uneWLhLf+WnWt2cR6RS3N4V79qc=", + "dev": true, + "requires": { + "expand-range": "1.8.2", + "preserve": "0.2.0", + "repeat-element": "1.1.2" + } + }, + "brorand": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/brorand/-/brorand-1.1.0.tgz", + "integrity": "sha1-EsJe/kCkXjwyPrhnWgoM5XsiNx8=", + "dev": true + }, + "brout": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/brout/-/brout-1.2.0.tgz", + "integrity": "sha1-B3Hav3ltMS8KfB8SgeAPdmDPcC8=", + "dev": true, + "requires": { + "through2": "2.0.3" + } + }, + "browser-pack": { + "version": "6.0.2", + "resolved": "https://registry.npmjs.org/browser-pack/-/browser-pack-6.0.2.tgz", + "integrity": "sha1-+GzWzvT1MAyOY+B6TVEvZfv/RTE=", + "dev": true, + "requires": { + "JSONStream": "1.3.1", + "combine-source-map": "0.7.2", + "defined": "1.0.0", + "through2": "2.0.3", + "umd": "3.0.1" + } + }, + "browser-reload": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/browser-reload/-/browser-reload-1.1.0.tgz", + "integrity": "sha1-UTwetc6RP+NqC6GOE5CcsHtCWpI=", + "dev": true + }, + "browser-resolve": { + "version": "1.11.2", + "resolved": "https://registry.npmjs.org/browser-resolve/-/browser-resolve-1.11.2.tgz", + "integrity": "sha1-j/CbCixCFxihBRwmCzLkj0QpOM4=", + "dev": true, + "requires": { + "resolve": "1.1.7" + }, + "dependencies": { + "resolve": { + "version": "1.1.7", + "resolved": "https://registry.npmjs.org/resolve/-/resolve-1.1.7.tgz", + "integrity": "sha1-IDEU2CrSxe2ejgQRs5ModeiJ6Xs=", + "dev": true + } + } + }, + "browser-stdout": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/browser-stdout/-/browser-stdout-1.3.0.tgz", + "integrity": "sha1-81HTKWnTL6XXpVZxVCY9korjvR8=", + "dev": true + }, + "browserify": { + "version": "14.4.0", + "resolved": "https://registry.npmjs.org/browserify/-/browserify-14.4.0.tgz", + "integrity": "sha1-CJo0Y69Y0OSNjNQHCz90ZU1avKk=", + "dev": true, + "requires": { + "JSONStream": "1.3.1", + "assert": "1.4.1", + "browser-pack": "6.0.2", + "browser-resolve": "1.11.2", + "browserify-zlib": "0.1.4", + "buffer": "5.0.8", + "cached-path-relative": "1.0.1", + "concat-stream": "1.5.2", + "console-browserify": "1.1.0", + "constants-browserify": "1.0.0", + "crypto-browserify": "3.11.1", + "defined": "1.0.0", + "deps-sort": "2.0.0", + "domain-browser": "1.1.7", + "duplexer2": "0.1.4", + "events": "1.1.1", + "glob": "7.1.2", + "has": "1.0.1", + "htmlescape": "1.1.1", + "https-browserify": "1.0.0", + "inherits": "2.0.3", + "insert-module-globals": "7.0.1", + "labeled-stream-splicer": "2.0.0", + "module-deps": "4.1.1", + "os-browserify": "0.1.2", + "parents": "1.0.1", + "path-browserify": "0.0.0", + "process": "0.11.10", + "punycode": "1.4.1", + "querystring-es3": "0.2.1", + "read-only-stream": "2.0.0", + "readable-stream": "2.3.3", + "resolve": "1.4.0", + "shasum": "1.0.2", + "shell-quote": "1.6.1", + "stream-browserify": "2.0.1", + "stream-http": "2.7.2", + "string_decoder": "1.0.3", + "subarg": "1.0.0", + "syntax-error": "1.3.0", + "through2": "2.0.3", + "timers-browserify": "1.4.2", + "tty-browserify": "0.0.0", + "url": "0.11.0", + "util": "0.10.3", + "vm-browserify": "0.0.4", + "xtend": "4.0.1" + } + }, + "browserify-aes": { + "version": "1.0.8", + "resolved": "https://registry.npmjs.org/browserify-aes/-/browserify-aes-1.0.8.tgz", + "integrity": "sha512-WYCMOT/PtGTlpOKFht0YJFYcPy6pLCR98CtWfzK13zoynLlBMvAdEMSRGmgnJCw2M2j/5qxBkinZQFobieM8dQ==", + "dev": true, + "requires": { + "buffer-xor": "1.0.3", + "cipher-base": "1.0.4", + "create-hash": "1.1.3", + "evp_bytestokey": "1.0.3", + "inherits": "2.0.3", + "safe-buffer": "5.1.1" + } + }, + "browserify-cipher": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/browserify-cipher/-/browserify-cipher-1.0.0.tgz", + "integrity": "sha1-mYgkSHS/XtTijalWZtzWasj8Njo=", + "dev": true, + "requires": { + "browserify-aes": "1.0.8", + "browserify-des": "1.0.0", + "evp_bytestokey": "1.0.3" + } + }, + "browserify-des": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/browserify-des/-/browserify-des-1.0.0.tgz", + "integrity": "sha1-2qJ3cXRwki7S/hhZQRihdUOXId0=", + "dev": true, + "requires": { + "cipher-base": "1.0.4", + "des.js": "1.0.0", + "inherits": "2.0.3" + } + }, + "browserify-rsa": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/browserify-rsa/-/browserify-rsa-4.0.1.tgz", + "integrity": "sha1-IeCr+vbyApzy+vsTNWenAdQTVSQ=", + "dev": true, + "requires": { + "bn.js": "4.11.8", + "randombytes": "2.0.5" + } + }, + "browserify-sign": { + "version": "4.0.4", + "resolved": "https://registry.npmjs.org/browserify-sign/-/browserify-sign-4.0.4.tgz", + "integrity": "sha1-qk62jl17ZYuqa/alfmMMvXqT0pg=", + "dev": true, + "requires": { + "bn.js": "4.11.8", + "browserify-rsa": "4.0.1", + "create-hash": "1.1.3", + "create-hmac": "1.1.6", + "elliptic": "6.4.0", + "inherits": "2.0.3", + "parse-asn1": "5.1.0" + } + }, + "browserify-zlib": { + "version": "0.1.4", + "resolved": "https://registry.npmjs.org/browserify-zlib/-/browserify-zlib-0.1.4.tgz", + "integrity": "sha1-uzX4pRn2AOD6a4SFJByXnQFB+y0=", + "dev": true, + "requires": { + "pako": "0.2.9" + } + }, + "buffer": { + "version": "5.0.8", + "resolved": "https://registry.npmjs.org/buffer/-/buffer-5.0.8.tgz", + "integrity": "sha512-xXvjQhVNz50v2nPeoOsNqWCLGfiv4ji/gXZM28jnVwdLJxH4mFyqgqCKfaK9zf1KUbG6zTkjLOy7ou+jSMarGA==", + "dev": true, + "requires": { + "base64-js": "1.2.1", + "ieee754": "1.1.8" + } + }, + "buffer-xor": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/buffer-xor/-/buffer-xor-1.0.3.tgz", + "integrity": "sha1-JuYe0UIvtw3ULm42cp7VHYVf6Nk=", + "dev": true + }, + "builtin-modules": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/builtin-modules/-/builtin-modules-1.1.1.tgz", + "integrity": "sha1-Jw8HbFpywC9bZaR9+Uxf46J4iS8=", + "dev": true + }, + "builtin-status-codes": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/builtin-status-codes/-/builtin-status-codes-3.0.0.tgz", + "integrity": "sha1-hZgoeOIbmOHGZCXgPQF0eI9Wnug=", + "dev": true + }, + "cached-path-relative": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/cached-path-relative/-/cached-path-relative-1.0.1.tgz", + "integrity": "sha1-0JxLUoAKpMB44t2BqGmqyQ0uVOc=", + "dev": true + }, + "caller-path": { + "version": "0.1.0", + "resolved": "https://registry.npmjs.org/caller-path/-/caller-path-0.1.0.tgz", + "integrity": "sha1-lAhe9jWB7NPaqSREqP6U6CV3dR8=", + "dev": true, + "requires": { + "callsites": "0.2.0" + } + }, + "callsites": { + "version": "0.2.0", + "resolved": "https://registry.npmjs.org/callsites/-/callsites-0.2.0.tgz", + "integrity": "sha1-r6uWJikQp/M8GaV3WCXGnzTjUMo=", + "dev": true + }, + "chalk": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-2.1.0.tgz", + "integrity": "sha512-LUHGS/dge4ujbXMJrnihYMcL4AoOweGnw9Tp3kQuqy1Kx5c1qKjqvMJZ6nVJPMWJtKCTN72ZogH3oeSO9g9rXQ==", + "dev": true, + "requires": { + "ansi-styles": "3.2.0", + "escape-string-regexp": "1.0.5", + "supports-color": "4.4.0" + }, + "dependencies": { + "ansi-styles": { + "version": "3.2.0", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-3.2.0.tgz", + "integrity": "sha512-NnSOmMEYtVR2JVMIGTzynRkkaxtiq1xnFBcdQD/DnNCYPoEPsVJhM98BDyaoNOQIi7p4okdi3E27eN7GQbsUug==", + "dev": true, + "requires": { + "color-convert": "1.9.0" + } + }, + "supports-color": { + "version": "4.4.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-4.4.0.tgz", + "integrity": "sha512-rKC3+DyXWgK0ZLKwmRsrkyHVZAjNkfzeehuFWdGGcqGDTZFH73+RH6S/RDAAxl9GusSjZSUWYLmT9N5pzXFOXQ==", + "dev": true, + "requires": { + "has-flag": "2.0.0" + } + } + } + }, + "chokidar": { + "version": "1.7.0", + "resolved": "https://registry.npmjs.org/chokidar/-/chokidar-1.7.0.tgz", + "integrity": "sha1-eY5ol3gVHIB2tLNg5e3SjNortGg=", + "dev": true, + "requires": { + "anymatch": "1.3.2", + "async-each": "1.0.1", + "glob-parent": "2.0.0", + "inherits": "2.0.3", + "is-binary-path": "1.0.1", + "is-glob": "2.0.1", + "path-is-absolute": "1.0.1", + "readdirp": "2.1.0" + }, + "dependencies": { + "is-extglob": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/is-extglob/-/is-extglob-1.0.0.tgz", + "integrity": "sha1-rEaBd8SUNAWgkvyPKXYMb/xiBsA=", + "dev": true + }, + "is-glob": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-2.0.1.tgz", + "integrity": "sha1-0Jb5JqPe1WAPP9/ZEZjLCIjC2GM=", + "dev": true, + "requires": { + "is-extglob": "1.0.0" + } + } + } + }, + "ci-info": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/ci-info/-/ci-info-1.1.1.tgz", + "integrity": "sha512-vHDDF/bP9RYpTWtUhpJRhCFdvvp3iDWvEbuDbWgvjUrNGV1MXJrE0MPcwGtEled04m61iwdBLUIHZtDgzWS4ZQ==", + "dev": true + }, + "cipher-base": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/cipher-base/-/cipher-base-1.0.4.tgz", + "integrity": "sha512-Kkht5ye6ZGmwv40uUDZztayT2ThLQGfnj/T71N/XzeZeo3nf8foyW7zGTsPYkEya3m5f3cAypH+qe7YOrM1U2Q==", + "dev": true, + "requires": { + "inherits": "2.0.3", + "safe-buffer": "5.1.1" + } + }, + "circular-json": { + "version": "0.3.3", + "resolved": "https://registry.npmjs.org/circular-json/-/circular-json-0.3.3.tgz", + "integrity": "sha512-UZK3NBx2Mca+b5LsG7bY183pHWt5Y1xts4P3Pz7ENTwGVnJOUWbRb3ocjvX7hx9tq/yTAdclXm9sZ38gNuem4A==", + "dev": true + }, + "cli-cursor": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/cli-cursor/-/cli-cursor-2.1.0.tgz", + "integrity": "sha1-s12sN2R5+sw+lHR9QdDQ9SOP/LU=", + "dev": true, + "requires": { + "restore-cursor": "2.0.0" + } + }, + "cli-spinners": { + "version": "0.1.2", + "resolved": "https://registry.npmjs.org/cli-spinners/-/cli-spinners-0.1.2.tgz", + "integrity": "sha1-u3ZNiOGF+54eaiofGXcjGPYF4xw=", + "dev": true + }, + "cli-truncate": { + "version": "0.2.1", + "resolved": "https://registry.npmjs.org/cli-truncate/-/cli-truncate-0.2.1.tgz", + "integrity": "sha1-nxXPuwcFAFNpIWxiasfQWrkN1XQ=", + "dev": true, + "requires": { + "slice-ansi": "0.0.4", + "string-width": "1.0.2" + }, + "dependencies": { + "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.1" + } + }, + "slice-ansi": { + "version": "0.0.4", + "resolved": "https://registry.npmjs.org/slice-ansi/-/slice-ansi-0.0.4.tgz", + "integrity": "sha1-7b+JA/ZvfOL46v1s7tZeJkyDGzU=", + "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.1.0", + "is-fullwidth-code-point": "1.0.0", + "strip-ansi": "3.0.1" + } + }, + "strip-ansi": { + "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.1.1" + } + } + } + }, + "cli-width": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/cli-width/-/cli-width-2.2.0.tgz", + "integrity": "sha1-/xnt6Kml5XkyQUewwR8PvLq+1jk=", + "dev": true + }, + "co": { + "version": "4.6.0", + "resolved": "https://registry.npmjs.org/co/-/co-4.6.0.tgz", + "integrity": "sha1-bqa989hTrlTMuOR7+gvz+QMfsYQ=", + "dev": true + }, + "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=", + "dev": true + }, + "color-convert": { + "version": "1.9.0", + "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-1.9.0.tgz", + "integrity": "sha1-Gsz5fdc5uYO/mU1W/sj5WFNkG3o=", + "dev": true, + "requires": { + "color-name": "1.1.3" + } + }, + "color-name": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.3.tgz", + "integrity": "sha1-p9BVi9icQveV3UIyj3QIMcpTvCU=", + "dev": true + }, + "combine-source-map": { + "version": "0.7.2", + "resolved": "https://registry.npmjs.org/combine-source-map/-/combine-source-map-0.7.2.tgz", + "integrity": "sha1-CHAxKFazB6h8xKxIbzqaYq7MwJ4=", + "dev": true, + "requires": { + "convert-source-map": "1.1.3", + "inline-source-map": "0.6.2", + "lodash.memoize": "3.0.4", + "source-map": "0.5.7" + } + }, + "commander": { + "version": "2.11.0", + "resolved": "https://registry.npmjs.org/commander/-/commander-2.11.0.tgz", + "integrity": "sha512-b0553uYA5YAEGgyYIGYROzKQ7X5RAqedkfjiZxwi0kL1g3bOaBNNZfYkzt/CL0umgD5wc9Jec2FbB98CjkMRvQ==", + "dev": true + }, + "concat-map": { + "version": "0.0.1", + "resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz", + "integrity": "sha1-2Klr13/Wjfd5OnMDajug1UBdR3s=", + "dev": true + }, + "concat-stream": { + "version": "1.5.2", + "resolved": "https://registry.npmjs.org/concat-stream/-/concat-stream-1.5.2.tgz", + "integrity": "sha1-cIl4Yk2FavQaWnQd790mHadSwmY=", + "dev": true, + "requires": { + "inherits": "2.0.3", + "readable-stream": "2.0.6", + "typedarray": "0.0.6" + }, + "dependencies": { + "readable-stream": { + "version": "2.0.6", + "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-2.0.6.tgz", + "integrity": "sha1-j5A0HmilPMySh4jaz80Rs265t44=", + "dev": true, + "requires": { + "core-util-is": "1.0.2", + "inherits": "2.0.3", + "isarray": "1.0.0", + "process-nextick-args": "1.0.7", + "string_decoder": "0.10.31", + "util-deprecate": "1.0.2" + } + }, + "string_decoder": { + "version": "0.10.31", + "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-0.10.31.tgz", + "integrity": "sha1-YuIDvEF2bGwoyfyEMB2rHFMQ+pQ=", + "dev": true + } + } + }, + "console-browserify": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/console-browserify/-/console-browserify-1.1.0.tgz", + "integrity": "sha1-8CQcRXMKn8YyOyBtvzjtx0HQuxA=", + "dev": true, + "requires": { + "date-now": "0.1.4" + } + }, + "consolify": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/consolify/-/consolify-2.2.0.tgz", + "integrity": "sha1-YiHbEHSgjYQP8wpcDLvzxgmnT4w=", + "dev": true, + "requires": { + "ansi_up": "1.3.0", + "brout": "1.2.0", + "browser-reload": "1.1.0", + "source-mapper": "2.0.0", + "through2": "2.0.3" + } + }, + "constants-browserify": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/constants-browserify/-/constants-browserify-1.0.0.tgz", + "integrity": "sha1-wguW2MYXdIqvHBYCF2DNJ/y4y3U=", + "dev": true + }, + "convert-source-map": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/convert-source-map/-/convert-source-map-1.1.3.tgz", + "integrity": "sha1-SCnId+n+SbMWHzvzZziI4gRpmGA=", + "dev": 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=", + "dev": true + }, + "cosmiconfig": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/cosmiconfig/-/cosmiconfig-1.1.0.tgz", + "integrity": "sha1-DeoPmATv37kp+7GxiOJVU+oFPTc=", + "dev": true, + "requires": { + "graceful-fs": "4.1.11", + "js-yaml": "3.10.0", + "minimist": "1.2.0", + "object-assign": "4.1.1", + "os-homedir": "1.0.2", + "parse-json": "2.2.0", + "pinkie-promise": "2.0.1", + "require-from-string": "1.2.1" + } + }, + "coverify": { + "version": "1.4.1", + "resolved": "https://registry.npmjs.org/coverify/-/coverify-1.4.1.tgz", + "integrity": "sha1-s+SwfsHOIJwOrJmliqvfZ9i2JyY=", + "dev": true, + "requires": { + "convert-source-map": "1.1.3", + "falafel": "1.2.0", + "minimist": "1.2.0", + "slash": "1.0.0", + "source-map": "0.4.4", + "split2": "0.2.1", + "stream-combiner2": "1.1.1", + "through2": "0.6.5" + }, + "dependencies": { + "isarray": { + "version": "0.0.1", + "resolved": "https://registry.npmjs.org/isarray/-/isarray-0.0.1.tgz", + "integrity": "sha1-ihis/Kmo9Bd+Cav8YDiTmwXR7t8=", + "dev": true + }, + "readable-stream": { + "version": "1.0.34", + "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-1.0.34.tgz", + "integrity": "sha1-Elgg40vIQtLyqq+v5MKRbuMsFXw=", + "dev": true, + "requires": { + "core-util-is": "1.0.2", + "inherits": "2.0.3", + "isarray": "0.0.1", + "string_decoder": "0.10.31" + } + }, + "source-map": { + "version": "0.4.4", + "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.4.4.tgz", + "integrity": "sha1-66T12pwNyZneaAMti092FzZSA2s=", + "dev": true, + "requires": { + "amdefine": "1.0.1" + } + }, + "string_decoder": { + "version": "0.10.31", + "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-0.10.31.tgz", + "integrity": "sha1-YuIDvEF2bGwoyfyEMB2rHFMQ+pQ=", + "dev": true + }, + "through2": { + "version": "0.6.5", + "resolved": "https://registry.npmjs.org/through2/-/through2-0.6.5.tgz", + "integrity": "sha1-QaucZ7KdVyCQcUEOHXp6lozTrUg=", + "dev": true, + "requires": { + "readable-stream": "1.0.34", + "xtend": "4.0.1" + } + } + } + }, + "create-ecdh": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/create-ecdh/-/create-ecdh-4.0.0.tgz", + "integrity": "sha1-iIxyNZbN92EvZJgjPuvXo1MBc30=", + "dev": true, + "requires": { + "bn.js": "4.11.8", + "elliptic": "6.4.0" + } + }, + "create-hash": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/create-hash/-/create-hash-1.1.3.tgz", + "integrity": "sha1-YGBCrIuSYnUPSDyt2rD1gZFy2P0=", + "dev": true, + "requires": { + "cipher-base": "1.0.4", + "inherits": "2.0.3", + "ripemd160": "2.0.1", + "sha.js": "2.4.9" + } + }, + "create-hmac": { + "version": "1.1.6", + "resolved": "https://registry.npmjs.org/create-hmac/-/create-hmac-1.1.6.tgz", + "integrity": "sha1-rLniIaThe9sHbpBlfEK5PjcmzwY=", + "dev": true, + "requires": { + "cipher-base": "1.0.4", + "create-hash": "1.1.3", + "inherits": "2.0.3", + "ripemd160": "2.0.1", + "safe-buffer": "5.1.1", + "sha.js": "2.4.9" + } + }, + "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.1.1", + "shebang-command": "1.2.0", + "which": "1.3.0" + } + }, + "cross-spawn-async": { + "version": "2.2.5", + "resolved": "https://registry.npmjs.org/cross-spawn-async/-/cross-spawn-async-2.2.5.tgz", + "integrity": "sha1-hF/wwINKPe2dFg2sptOQkGuyiMw=", + "dev": true, + "requires": { + "lru-cache": "4.1.1", + "which": "1.3.0" + } + }, + "crypto-browserify": { + "version": "3.11.1", + "resolved": "https://registry.npmjs.org/crypto-browserify/-/crypto-browserify-3.11.1.tgz", + "integrity": "sha512-Na7ZlwCOqoaW5RwUK1WpXws2kv8mNhWdTlzob0UXulk6G9BDbyiJaGTYBIX61Ozn9l1EPPJpICZb4DaOpT9NlQ==", + "dev": true, + "requires": { + "browserify-cipher": "1.0.0", + "browserify-sign": "4.0.4", + "create-ecdh": "4.0.0", + "create-hash": "1.1.3", + "create-hmac": "1.1.6", + "diffie-hellman": "5.0.2", + "inherits": "2.0.3", + "pbkdf2": "3.0.14", + "public-encrypt": "4.0.0", + "randombytes": "2.0.5" + } + }, + "date-fns": { + "version": "1.28.5", + "resolved": "https://registry.npmjs.org/date-fns/-/date-fns-1.28.5.tgz", + "integrity": "sha1-JXz8RdMi30XvVlhmWWfuhBzXP68=", + "dev": true + }, + "date-now": { + "version": "0.1.4", + "resolved": "https://registry.npmjs.org/date-now/-/date-now-0.1.4.tgz", + "integrity": "sha1-6vQ5/U1ISK105cx9vvIAZyueNFs=", + "dev": true + }, + "debug": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/debug/-/debug-3.1.0.tgz", + "integrity": "sha512-OX8XqP7/1a9cqkxYw2yXss15f26NKWBpDXQd0/uK/KPqdQhxbPa994hnzjcE2VqQpDslf55723cKPUOGSmMY3g==", + "dev": true, + "requires": { + "ms": "2.0.0" + } + }, + "deep-is": { + "version": "0.1.3", + "resolved": "https://registry.npmjs.org/deep-is/-/deep-is-0.1.3.tgz", + "integrity": "sha1-s2nW+128E+7PUk+RsHD+7cNXzzQ=", + "dev": true + }, + "define-properties": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/define-properties/-/define-properties-1.1.2.tgz", + "integrity": "sha1-g6c/L+pWmJj7c3GTyPhzyvbUXJQ=", + "dev": true, + "requires": { + "foreach": "2.0.5", + "object-keys": "1.0.11" + } + }, + "defined": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/defined/-/defined-1.0.0.tgz", + "integrity": "sha1-yY2bzvdWdBiOEQlpFRGZ45sfppM=", + "dev": true + }, + "del": { + "version": "2.2.2", + "resolved": "https://registry.npmjs.org/del/-/del-2.2.2.tgz", + "integrity": "sha1-wSyYHQZ4RshLyvhiz/kw2Qf/0ag=", + "dev": true, + "requires": { + "globby": "5.0.0", + "is-path-cwd": "1.0.0", + "is-path-in-cwd": "1.0.0", + "object-assign": "4.1.1", + "pify": "2.3.0", + "pinkie-promise": "2.0.1", + "rimraf": "2.6.2" + } + }, + "deps-sort": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/deps-sort/-/deps-sort-2.0.0.tgz", + "integrity": "sha1-CRckkC6EZYJg65EHSMzNGvbiH7U=", + "dev": true, + "requires": { + "JSONStream": "1.3.1", + "shasum": "1.0.2", + "subarg": "1.0.0", + "through2": "2.0.3" + } + }, + "des.js": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/des.js/-/des.js-1.0.0.tgz", + "integrity": "sha1-wHTS4qpqipoH29YfmhXCzYPsjsw=", + "dev": true, + "requires": { + "inherits": "2.0.3", + "minimalistic-assert": "1.0.0" + } + }, + "detective": { + "version": "4.5.0", + "resolved": "https://registry.npmjs.org/detective/-/detective-4.5.0.tgz", + "integrity": "sha1-blqMaybmx6JUsca210kNmOyR7dE=", + "dev": true, + "requires": { + "acorn": "4.0.13", + "defined": "1.0.0" + } + }, + "diff": { + "version": "3.2.0", + "resolved": "https://registry.npmjs.org/diff/-/diff-3.2.0.tgz", + "integrity": "sha1-yc45Okt8vQsFinJck98pkCeGj/k=", + "dev": true + }, + "diffie-hellman": { + "version": "5.0.2", + "resolved": "https://registry.npmjs.org/diffie-hellman/-/diffie-hellman-5.0.2.tgz", + "integrity": "sha1-tYNXOScM/ias9jIJn97SoH8gnl4=", + "dev": true, + "requires": { + "bn.js": "4.11.8", + "miller-rabin": "4.0.1", + "randombytes": "2.0.5" + } + }, + "doctrine": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/doctrine/-/doctrine-2.0.0.tgz", + "integrity": "sha1-xz2NKQnSIpHhoAejlYBNqLZl/mM=", + "dev": true, + "requires": { + "esutils": "2.0.2", + "isarray": "1.0.0" + } + }, + "domain-browser": { + "version": "1.1.7", + "resolved": "https://registry.npmjs.org/domain-browser/-/domain-browser-1.1.7.tgz", + "integrity": "sha1-hnqksJP6oF8d4IwG9NeyH9+GmLw=", + "dev": true + }, + "duplexer": { + "version": "0.1.1", + "resolved": "https://registry.npmjs.org/duplexer/-/duplexer-0.1.1.tgz", + "integrity": "sha1-rOb/gIwc5mtX0ev5eXessCM0z8E=", + "dev": true + }, + "duplexer2": { + "version": "0.1.4", + "resolved": "https://registry.npmjs.org/duplexer2/-/duplexer2-0.1.4.tgz", + "integrity": "sha1-ixLauHjA1p4+eJEFFmKjL8a93ME=", + "dev": true, + "requires": { + "readable-stream": "2.3.3" + } + }, + "elegant-spinner": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/elegant-spinner/-/elegant-spinner-1.0.1.tgz", + "integrity": "sha1-2wQ1IcldfjA/2PNFvtwzSc+wcp4=", + "dev": true + }, + "elliptic": { + "version": "6.4.0", + "resolved": "https://registry.npmjs.org/elliptic/-/elliptic-6.4.0.tgz", + "integrity": "sha1-ysmvh2LIWDYYcAPI3+GT5eLq5d8=", + "dev": true, + "requires": { + "bn.js": "4.11.8", + "brorand": "1.1.0", + "hash.js": "1.1.3", + "hmac-drbg": "1.0.1", + "inherits": "2.0.3", + "minimalistic-assert": "1.0.0", + "minimalistic-crypto-utils": "1.0.1" + } + }, + "error-ex": { + "version": "1.3.1", + "resolved": "https://registry.npmjs.org/error-ex/-/error-ex-1.3.1.tgz", + "integrity": "sha1-+FWobOYa3E6GIcPNoh56dhLDqNw=", + "dev": true, + "requires": { + "is-arrayish": "0.2.1" + } + }, + "es-abstract": { + "version": "1.9.0", + "resolved": "https://registry.npmjs.org/es-abstract/-/es-abstract-1.9.0.tgz", + "integrity": "sha512-kk3IJoKo7A3pWJc0OV8yZ/VEX2oSUytfekrJiqoxBlKJMFAJVJVpGdHClCCTdv+Fn2zHfpDHHIelMFhZVfef3Q==", + "dev": true, + "requires": { + "es-to-primitive": "1.1.1", + "function-bind": "1.1.1", + "has": "1.0.1", + "is-callable": "1.1.3", + "is-regex": "1.0.4" + } + }, + "es-to-primitive": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/es-to-primitive/-/es-to-primitive-1.1.1.tgz", + "integrity": "sha1-RTVSSKiJeQNLZ5Lhm7gfK3l13Q0=", + "dev": true, + "requires": { + "is-callable": "1.1.3", + "is-date-object": "1.0.1", + "is-symbol": "1.0.1" + } + }, + "es5-shim": { + "version": "4.5.9", + "resolved": "https://registry.npmjs.org/es5-shim/-/es5-shim-4.5.9.tgz", + "integrity": "sha1-Kh4rnlg/9f7Qwgo+4svz91IwpcA=", + "dev": true + }, + "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=", + "dev": true + }, + "eslint": { + "version": "4.8.0", + "resolved": "https://registry.npmjs.org/eslint/-/eslint-4.8.0.tgz", + "integrity": "sha1-Ip7w41Tg5h2DfHqA/fuoJeGZgV4=", + "dev": true, + "requires": { + "ajv": "5.2.3", + "babel-code-frame": "6.26.0", + "chalk": "2.1.0", + "concat-stream": "1.6.0", + "cross-spawn": "5.1.0", + "debug": "3.1.0", + "doctrine": "2.0.0", + "eslint-scope": "3.7.1", + "espree": "3.5.1", + "esquery": "1.0.0", + "estraverse": "4.2.0", + "esutils": "2.0.2", + "file-entry-cache": "2.0.0", + "functional-red-black-tree": "1.0.1", + "glob": "7.1.2", + "globals": "9.18.0", + "ignore": "3.3.5", + "imurmurhash": "0.1.4", + "inquirer": "3.3.0", + "is-resolvable": "1.0.0", + "js-yaml": "3.10.0", + "json-stable-stringify": "1.0.1", + "levn": "0.3.0", + "lodash": "4.17.4", + "minimatch": "3.0.4", + "mkdirp": "0.5.1", + "natural-compare": "1.4.0", + "optionator": "0.8.2", + "path-is-inside": "1.0.2", + "pluralize": "7.0.0", + "progress": "2.0.0", + "require-uncached": "1.0.3", + "semver": "5.4.1", + "strip-ansi": "4.0.0", + "strip-json-comments": "2.0.1", + "table": "4.0.2", + "text-table": "0.2.0" + }, + "dependencies": { + "concat-stream": { + "version": "1.6.0", + "resolved": "https://registry.npmjs.org/concat-stream/-/concat-stream-1.6.0.tgz", + "integrity": "sha1-CqxmL9Ur54lk1VMvaUeE5wEQrPc=", + "dev": true, + "requires": { + "inherits": "2.0.3", + "readable-stream": "2.3.3", + "typedarray": "0.0.6" + } + }, + "json-stable-stringify": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/json-stable-stringify/-/json-stable-stringify-1.0.1.tgz", + "integrity": "sha1-mnWdOcXy/1A/1TAGRu1EX4jE+a8=", + "dev": true, + "requires": { + "jsonify": "0.0.0" + } + } + } + }, + "eslint-config-sinon": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/eslint-config-sinon/-/eslint-config-sinon-1.0.3.tgz", + "integrity": "sha1-6vcFIqGL8yUKuQMcfEPw2LD0Daw=", + "dev": true + }, + "eslint-plugin-mocha": { + "version": "4.11.0", + "resolved": "https://registry.npmjs.org/eslint-plugin-mocha/-/eslint-plugin-mocha-4.11.0.tgz", + "integrity": "sha1-kRk6L1XiCl41l0BUoAidMBmO5Xg=", + "dev": true, + "requires": { + "ramda": "0.24.1" + } + }, + "eslint-scope": { + "version": "3.7.1", + "resolved": "https://registry.npmjs.org/eslint-scope/-/eslint-scope-3.7.1.tgz", + "integrity": "sha1-PWPD7f2gLgbgGkUq2IyqzHzctug=", + "dev": true, + "requires": { + "esrecurse": "4.2.0", + "estraverse": "4.2.0" + } + }, + "espree": { + "version": "3.5.1", + "resolved": "https://registry.npmjs.org/espree/-/espree-3.5.1.tgz", + "integrity": "sha1-DJiLirRttTEAoZVK5LqZXd0n2H4=", + "dev": true, + "requires": { + "acorn": "5.1.2", + "acorn-jsx": "3.0.1" + }, + "dependencies": { + "acorn": { + "version": "5.1.2", + "resolved": "https://registry.npmjs.org/acorn/-/acorn-5.1.2.tgz", + "integrity": "sha512-o96FZLJBPY1lvTuJylGA9Bk3t/GKPPJG8H0ydQQl01crzwJgspa4AEIq/pVTXigmK0PHVQhiAtn8WMBLL9D2WA==", + "dev": true + } + } + }, + "esprima": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/esprima/-/esprima-4.0.0.tgz", + "integrity": "sha512-oftTcaMu/EGrEIu904mWteKIv8vMuOgGYo7EhVJJN00R/EED9DCua/xxHRdYnKtcECzVg7xOWhflvJMnqcFZjw==", + "dev": true + }, + "esquery": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/esquery/-/esquery-1.0.0.tgz", + "integrity": "sha1-z7qLV9f7qT8XKYqKAGoEzaE9gPo=", + "dev": true, + "requires": { + "estraverse": "4.2.0" + } + }, + "esrecurse": { + "version": "4.2.0", + "resolved": "https://registry.npmjs.org/esrecurse/-/esrecurse-4.2.0.tgz", + "integrity": "sha1-+pVo2Y04I/mkHZHpAtyrnqblsWM=", + "dev": true, + "requires": { + "estraverse": "4.2.0", + "object-assign": "4.1.1" + } + }, + "estraverse": { + "version": "4.2.0", + "resolved": "https://registry.npmjs.org/estraverse/-/estraverse-4.2.0.tgz", + "integrity": "sha1-De4/7TH81GlhjOc0IJn8GvoL2xM=", + "dev": true + }, + "esutils": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/esutils/-/esutils-2.0.2.tgz", + "integrity": "sha1-Cr9PHKpbyx96nYrMbepPqqBLrJs=", + "dev": true + }, + "event-stream": { + "version": "3.3.4", + "resolved": "https://registry.npmjs.org/event-stream/-/event-stream-3.3.4.tgz", + "integrity": "sha1-SrTJoPWlTbkzi0w02Gv86PSzVXE=", + "dev": true, + "requires": { + "duplexer": "0.1.1", + "from": "0.1.7", + "map-stream": "0.1.0", + "pause-stream": "0.0.11", + "split": "0.3.3", + "stream-combiner": "0.0.4", + "through": "2.3.8" + } + }, + "events": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/events/-/events-1.1.1.tgz", + "integrity": "sha1-nr23Y1rQmccNzEwqH1AEKI6L2SQ=", + "dev": true + }, + "evp_bytestokey": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/evp_bytestokey/-/evp_bytestokey-1.0.3.tgz", + "integrity": "sha512-/f2Go4TognH/KvCISP7OUsHn85hT9nUkxxA9BEWxFn+Oj9o8ZNLm/40hdlgSLyuOimsrTKLUMEorQexp/aPQeA==", + "dev": true, + "requires": { + "md5.js": "1.3.4", + "safe-buffer": "5.1.1" + } + }, + "execa": { + "version": "0.8.0", + "resolved": "https://registry.npmjs.org/execa/-/execa-0.8.0.tgz", + "integrity": "sha1-2NdrvBtVIX7RkP1t1J08d07PyNo=", + "dev": true, + "requires": { + "cross-spawn": "5.1.0", + "get-stream": "3.0.0", + "is-stream": "1.1.0", + "npm-run-path": "2.0.2", + "p-finally": "1.0.0", + "signal-exit": "3.0.2", + "strip-eof": "1.0.0" + } + }, + "exit-hook": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/exit-hook/-/exit-hook-1.1.1.tgz", + "integrity": "sha1-8FyiM7SMBdVP/wd2XfhQfpXAL/g=", + "dev": true + }, + "expand-brackets": { + "version": "0.1.5", + "resolved": "https://registry.npmjs.org/expand-brackets/-/expand-brackets-0.1.5.tgz", + "integrity": "sha1-3wcoTjQqgHzXM6xa9yQR5YHRF3s=", + "dev": true, + "requires": { + "is-posix-bracket": "0.1.1" + } + }, + "expand-range": { + "version": "1.8.2", + "resolved": "https://registry.npmjs.org/expand-range/-/expand-range-1.8.2.tgz", + "integrity": "sha1-opnv/TNf4nIeuujiV+x5ZE/IUzc=", + "dev": true, + "requires": { + "fill-range": "2.2.3" + } + }, + "extend": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/extend/-/extend-3.0.1.tgz", + "integrity": "sha1-p1Xqe8Gt/MWjHOfnYtuq3F5jZEQ=", + "dev": true + }, + "external-editor": { + "version": "2.0.5", + "resolved": "https://registry.npmjs.org/external-editor/-/external-editor-2.0.5.tgz", + "integrity": "sha512-Msjo64WT5W+NhOpQXh0nOHm+n0RfU1QUwDnKYvJ8dEJ8zlwLrqXNTv5mSUTJpepf41PDJGyhueTw2vNZW+Fr/w==", + "dev": true, + "requires": { + "iconv-lite": "0.4.19", + "jschardet": "1.5.1", + "tmp": "0.0.33" + } + }, + "extglob": { + "version": "0.3.2", + "resolved": "https://registry.npmjs.org/extglob/-/extglob-0.3.2.tgz", + "integrity": "sha1-Lhj/PS9JqydlzskCPwEdqo2DSaE=", + "dev": true, + "requires": { + "is-extglob": "1.0.0" + }, + "dependencies": { + "is-extglob": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/is-extglob/-/is-extglob-1.0.0.tgz", + "integrity": "sha1-rEaBd8SUNAWgkvyPKXYMb/xiBsA=", + "dev": true + } + } + }, + "falafel": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/falafel/-/falafel-1.2.0.tgz", + "integrity": "sha1-wY0k71CRF0pJfzGM0ksCaiXN2rQ=", + "dev": true, + "requires": { + "acorn": "1.2.2", + "foreach": "2.0.5", + "isarray": "0.0.1", + "object-keys": "1.0.11" + }, + "dependencies": { + "acorn": { + "version": "1.2.2", + "resolved": "https://registry.npmjs.org/acorn/-/acorn-1.2.2.tgz", + "integrity": "sha1-yM4n3grMdtiW0rH6099YjZ6C8BQ=", + "dev": true + }, + "isarray": { + "version": "0.0.1", + "resolved": "https://registry.npmjs.org/isarray/-/isarray-0.0.1.tgz", + "integrity": "sha1-ihis/Kmo9Bd+Cav8YDiTmwXR7t8=", + "dev": true + } + } + }, + "fast-deep-equal": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-1.0.0.tgz", + "integrity": "sha1-liVqO8l1WV6zbYLpkp0GDYk0Of8=", + "dev": true + }, + "fast-levenshtein": { + "version": "2.0.6", + "resolved": "https://registry.npmjs.org/fast-levenshtein/-/fast-levenshtein-2.0.6.tgz", + "integrity": "sha1-PYpcZog6FqMMqGQ+hR8Zuqd5eRc=", + "dev": true + }, + "figures": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/figures/-/figures-2.0.0.tgz", + "integrity": "sha1-OrGi0qYsi/tDGgyUy3l6L84nyWI=", + "dev": true, + "requires": { + "escape-string-regexp": "1.0.5" + } + }, + "file-entry-cache": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/file-entry-cache/-/file-entry-cache-2.0.0.tgz", + "integrity": "sha1-w5KZDD5oR4PYOLjISkXYoEhFg2E=", + "dev": true, + "requires": { + "flat-cache": "1.3.0", + "object-assign": "4.1.1" + } + }, + "filename-regex": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/filename-regex/-/filename-regex-2.0.1.tgz", + "integrity": "sha1-wcS5vuPglyXdsQa3XB4wH+LxiyY=", + "dev": true + }, + "fill-range": { + "version": "2.2.3", + "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-2.2.3.tgz", + "integrity": "sha1-ULd9/X5Gm8dJJHCWNpn+eoSFpyM=", + "dev": true, + "requires": { + "is-number": "2.1.0", + "isobject": "2.1.0", + "randomatic": "1.1.7", + "repeat-element": "1.1.2", + "repeat-string": "1.6.1" + } + }, + "flat-cache": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/flat-cache/-/flat-cache-1.3.0.tgz", + "integrity": "sha1-0wMLMrOBVPTjt+nHCfSQ9++XxIE=", + "dev": true, + "requires": { + "circular-json": "0.3.3", + "del": "2.2.2", + "graceful-fs": "4.1.11", + "write": "0.2.1" + } + }, + "for-in": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/for-in/-/for-in-1.0.2.tgz", + "integrity": "sha1-gQaNKVqBQuwKxybG4iAMMPttXoA=", + "dev": true + }, + "for-own": { + "version": "0.1.5", + "resolved": "https://registry.npmjs.org/for-own/-/for-own-0.1.5.tgz", + "integrity": "sha1-UmXGgaTylNq78XyVCbZ2OqhFEM4=", + "dev": true, + "requires": { + "for-in": "1.0.2" + } + }, + "foreach": { + "version": "2.0.5", + "resolved": "https://registry.npmjs.org/foreach/-/foreach-2.0.5.tgz", + "integrity": "sha1-C+4AUBiusmDQo6865ljdATbsG5k=", + "dev": true + }, + "formatio": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/formatio/-/formatio-1.2.0.tgz", + "integrity": "sha1-87IWfZBoxGmKjVH092CjmlTYGOs=", + "dev": true, + "requires": { + "samsam": "1.3.0" + } + }, + "from": { + "version": "0.1.7", + "resolved": "https://registry.npmjs.org/from/-/from-0.1.7.tgz", + "integrity": "sha1-g8YK/Fi5xWmXAH7Rp2izqzA6RP4=", + "dev": true + }, + "fs.realpath": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/fs.realpath/-/fs.realpath-1.0.0.tgz", + "integrity": "sha1-FQStJSMVjKpA20onh8sBQRmU6k8=", + "dev": true + }, + "function-bind": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.1.tgz", + "integrity": "sha512-yIovAzMX49sF8Yl58fSCWJ5svSLuaibPxXQJFLmBObTuCr0Mf1KiPopGM9NiFjiYBCbfaa2Fh6breQ6ANVTI0A==", + "dev": true + }, + "functional-red-black-tree": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/functional-red-black-tree/-/functional-red-black-tree-1.0.1.tgz", + "integrity": "sha1-GwqzvVU7Kg1jmdKcDj6gslIHgyc=", + "dev": true + }, + "get-own-enumerable-property-symbols": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/get-own-enumerable-property-symbols/-/get-own-enumerable-property-symbols-2.0.1.tgz", + "integrity": "sha512-TtY/sbOemiMKPRUDDanGCSgBYe7Mf0vbRsWnBZ+9yghpZ1MvcpSpuZFjHdEeY/LZjZy0vdLjS77L6HosisFiug==", + "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 + }, + "glob": { + "version": "7.1.2", + "resolved": "https://registry.npmjs.org/glob/-/glob-7.1.2.tgz", + "integrity": "sha512-MJTUg1kjuLeQCJ+ccE4Vpa6kKVXkPYJ2mOCQyUuKLcLQsdrMCpBPUi8qVE6+YuaJkozeA9NusTAw3hLr8Xe5EQ==", + "dev": true, + "requires": { + "fs.realpath": "1.0.0", + "inflight": "1.0.6", + "inherits": "2.0.3", + "minimatch": "3.0.4", + "once": "1.4.0", + "path-is-absolute": "1.0.1" + } + }, + "glob-base": { + "version": "0.3.0", + "resolved": "https://registry.npmjs.org/glob-base/-/glob-base-0.3.0.tgz", + "integrity": "sha1-27Fk9iIbHAscz4Kuoyi0l98Oo8Q=", + "dev": true, + "requires": { + "glob-parent": "2.0.0", + "is-glob": "2.0.1" + }, + "dependencies": { + "is-extglob": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/is-extglob/-/is-extglob-1.0.0.tgz", + "integrity": "sha1-rEaBd8SUNAWgkvyPKXYMb/xiBsA=", + "dev": true + }, + "is-glob": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-2.0.1.tgz", + "integrity": "sha1-0Jb5JqPe1WAPP9/ZEZjLCIjC2GM=", + "dev": true, + "requires": { + "is-extglob": "1.0.0" + } + } + } + }, + "glob-parent": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-2.0.0.tgz", + "integrity": "sha1-gTg9ctsFT8zPUzbaqQLxgvbtuyg=", + "dev": true, + "requires": { + "is-glob": "2.0.1" + }, + "dependencies": { + "is-extglob": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/is-extglob/-/is-extglob-1.0.0.tgz", + "integrity": "sha1-rEaBd8SUNAWgkvyPKXYMb/xiBsA=", + "dev": true + }, + "is-glob": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-2.0.1.tgz", + "integrity": "sha1-0Jb5JqPe1WAPP9/ZEZjLCIjC2GM=", + "dev": true, + "requires": { + "is-extglob": "1.0.0" + } + } + } + }, + "globals": { + "version": "9.18.0", + "resolved": "https://registry.npmjs.org/globals/-/globals-9.18.0.tgz", + "integrity": "sha512-S0nG3CLEQiY/ILxqtztTWH/3iRRdyBLw6KMDxnKMchrtbj2OFmehVh0WUCfW3DUrIgx/qFrJPICrq4Z4sTR9UQ==", + "dev": true + }, + "globby": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/globby/-/globby-5.0.0.tgz", + "integrity": "sha1-69hGZ8oNuzMLmbz8aOrCvFQ3Dg0=", + "dev": true, + "requires": { + "array-union": "1.0.2", + "arrify": "1.0.1", + "glob": "7.1.2", + "object-assign": "4.1.1", + "pify": "2.3.0", + "pinkie-promise": "2.0.1" + } + }, + "graceful-fs": { + "version": "4.1.11", + "resolved": "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.1.11.tgz", + "integrity": "sha1-Dovf5NHduIVNZOBOp8AOKgJuVlg=", + "dev": true + }, + "graceful-readlink": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/graceful-readlink/-/graceful-readlink-1.0.1.tgz", + "integrity": "sha1-TK+tdrxi8C+gObL5Tpo906ORpyU=", + "dev": true + }, + "growl": { + "version": "1.9.2", + "resolved": "https://registry.npmjs.org/growl/-/growl-1.9.2.tgz", + "integrity": "sha1-Dqd0NxXbjY3ixe3hd14bRayFwC8=", + "dev": true + }, + "has": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/has/-/has-1.0.1.tgz", + "integrity": "sha1-hGFzP1OLCDfJNh45qauelwTcLyg=", + "dev": true, + "requires": { + "function-bind": "1.1.1" + } + }, + "has-ansi": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/has-ansi/-/has-ansi-2.0.0.tgz", + "integrity": "sha1-NPUEnOHs3ysGSa8+8k5F7TVBbZE=", + "dev": true, + "requires": { + "ansi-regex": "2.1.1" + } + }, + "has-flag": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-2.0.0.tgz", + "integrity": "sha1-6CB68cx7MNRGzHC3NLXovhj4jVE=", + "dev": true + }, + "hash-base": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/hash-base/-/hash-base-2.0.2.tgz", + "integrity": "sha1-ZuodhW206KVHDK32/OI65SRO8uE=", + "dev": true, + "requires": { + "inherits": "2.0.3" + } + }, + "hash.js": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/hash.js/-/hash.js-1.1.3.tgz", + "integrity": "sha512-/UETyP0W22QILqS+6HowevwhEFJ3MBJnwTf75Qob9Wz9t0DPuisL8kW8YZMK62dHAKE1c1p+gY1TtOLY+USEHA==", + "dev": true, + "requires": { + "inherits": "2.0.3", + "minimalistic-assert": "1.0.0" + } + }, + "he": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/he/-/he-1.1.1.tgz", + "integrity": "sha1-k0EP0hsAlzUVH4howvJx80J+I/0=", + "dev": true + }, + "hmac-drbg": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/hmac-drbg/-/hmac-drbg-1.0.1.tgz", + "integrity": "sha1-0nRXAQJabHdabFRXk+1QL8DGSaE=", + "dev": true, + "requires": { + "hash.js": "1.1.3", + "minimalistic-assert": "1.0.0", + "minimalistic-crypto-utils": "1.0.1" + } + }, + "hosted-git-info": { + "version": "2.5.0", + "resolved": "https://registry.npmjs.org/hosted-git-info/-/hosted-git-info-2.5.0.tgz", + "integrity": "sha512-pNgbURSuab90KbTqvRPsseaTxOJCZBD0a7t+haSN33piP9cCM4l0CqdzAif2hUqm716UovKB2ROmiabGAKVXyg==", + "dev": true + }, + "htmlescape": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/htmlescape/-/htmlescape-1.1.1.tgz", + "integrity": "sha1-OgPtwiFLyjtmQko+eVk0lQnLA1E=", + "dev": true + }, + "https-browserify": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/https-browserify/-/https-browserify-1.0.0.tgz", + "integrity": "sha1-7AbBDgo0wPL68Zn3/X/Hj//QPHM=", + "dev": true + }, + "https-proxy-agent": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/https-proxy-agent/-/https-proxy-agent-1.0.0.tgz", + "integrity": "sha1-NffabEjOTdv6JkiRrFk+5f+GceY=", + "dev": true, + "requires": { + "agent-base": "2.1.1", + "debug": "2.6.9", + "extend": "3.0.1" + }, + "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" + } + } + } + }, + "husky": { + "version": "0.14.3", + "resolved": "https://registry.npmjs.org/husky/-/husky-0.14.3.tgz", + "integrity": "sha512-e21wivqHpstpoiWA/Yi8eFti8E+sQDSS53cpJsPptPs295QTOQR0ZwnHo2TXy1XOpZFD9rPOd3NpmqTK6uMLJA==", + "dev": true, + "requires": { + "is-ci": "1.0.10", + "normalize-path": "1.0.0", + "strip-indent": "2.0.0" + } + }, + "iconv-lite": { + "version": "0.4.19", + "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.4.19.tgz", + "integrity": "sha512-oTZqweIP51xaGPI4uPa56/Pri/480R+mo7SeU+YETByQNhDG55ycFyNLIgta9vXhILrxXDmF7ZGhqZIcuN0gJQ==", + "dev": true + }, + "ieee754": { + "version": "1.1.8", + "resolved": "https://registry.npmjs.org/ieee754/-/ieee754-1.1.8.tgz", + "integrity": "sha1-vjPUCsEO8ZJnAfbwii2G+/0a0+Q=", + "dev": true + }, + "ignore": { + "version": "3.3.5", + "resolved": "https://registry.npmjs.org/ignore/-/ignore-3.3.5.tgz", + "integrity": "sha512-JLH93mL8amZQhh/p6mfQgVBH3M6epNq3DfsXsTSuSrInVjwyYlFE1nv2AgfRCC8PoOhM0jwQ5v8s9LgbK7yGDw==", + "dev": true + }, + "imurmurhash": { + "version": "0.1.4", + "resolved": "https://registry.npmjs.org/imurmurhash/-/imurmurhash-0.1.4.tgz", + "integrity": "sha1-khi5srkoojixPcT7a21XbyMUU+o=", + "dev": true + }, + "indent-string": { + "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.1" + } + }, + "indexof": { + "version": "0.0.1", + "resolved": "https://registry.npmjs.org/indexof/-/indexof-0.0.1.tgz", + "integrity": "sha1-gtwzbSMrkGIXnQWrMpOmYFn9Q10=", + "dev": true + }, + "inflight": { + "version": "1.0.6", + "resolved": "https://registry.npmjs.org/inflight/-/inflight-1.0.6.tgz", + "integrity": "sha1-Sb1jMdfQLQwJvJEKEHW6gWW1bfk=", + "dev": true, + "requires": { + "once": "1.4.0", + "wrappy": "1.0.2" + } + }, + "inherits": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.3.tgz", + "integrity": "sha1-Yzwsg+PaQqUC9SRmAiSA9CCCYd4=", + "dev": true + }, + "inline-source-map": { + "version": "0.6.2", + "resolved": "https://registry.npmjs.org/inline-source-map/-/inline-source-map-0.6.2.tgz", + "integrity": "sha1-+Tk0ccGKedFyT4Y/o4tYY3Ct4qU=", + "dev": true, + "requires": { + "source-map": "0.5.7" + } + }, + "inquirer": { + "version": "3.3.0", + "resolved": "https://registry.npmjs.org/inquirer/-/inquirer-3.3.0.tgz", + "integrity": "sha512-h+xtnyk4EwKvFWHrUYsWErEVR+igKtLdchu+o0Z1RL7VU/jVMFbYir2bp6bAj8efFNxWqHX0dIss6fJQ+/+qeQ==", + "dev": true, + "requires": { + "ansi-escapes": "3.0.0", + "chalk": "2.1.0", + "cli-cursor": "2.1.0", + "cli-width": "2.2.0", + "external-editor": "2.0.5", + "figures": "2.0.0", + "lodash": "4.17.4", + "mute-stream": "0.0.7", + "run-async": "2.3.0", + "rx-lite": "4.0.8", + "rx-lite-aggregates": "4.0.8", + "string-width": "2.1.1", + "strip-ansi": "4.0.0", + "through": "2.3.8" + } + }, + "insert-module-globals": { + "version": "7.0.1", + "resolved": "https://registry.npmjs.org/insert-module-globals/-/insert-module-globals-7.0.1.tgz", + "integrity": "sha1-wDv04BywhtW15azorQr+eInWOMM=", + "dev": true, + "requires": { + "JSONStream": "1.3.1", + "combine-source-map": "0.7.2", + "concat-stream": "1.5.2", + "is-buffer": "1.1.5", + "lexical-scope": "1.2.0", + "process": "0.11.10", + "through2": "2.0.3", + "xtend": "4.0.1" + } + }, + "is-arrayish": { + "version": "0.2.1", + "resolved": "https://registry.npmjs.org/is-arrayish/-/is-arrayish-0.2.1.tgz", + "integrity": "sha1-d8mYQFJ6qOyxqLppe4BkWnqSap0=", + "dev": true + }, + "is-binary-path": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/is-binary-path/-/is-binary-path-1.0.1.tgz", + "integrity": "sha1-dfFmQrSA8YenEcgUFh/TpKdlWJg=", + "dev": true, + "requires": { + "binary-extensions": "1.10.0" + } + }, + "is-buffer": { + "version": "1.1.5", + "resolved": "https://registry.npmjs.org/is-buffer/-/is-buffer-1.1.5.tgz", + "integrity": "sha1-Hzsm72E7IUuIy8ojzGwB2Hlh7sw=", + "dev": true + }, + "is-builtin-module": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/is-builtin-module/-/is-builtin-module-1.0.0.tgz", + "integrity": "sha1-VAVy0096wxGfj3bDDLwbHgN6/74=", + "dev": true, + "requires": { + "builtin-modules": "1.1.1" + } + }, + "is-callable": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/is-callable/-/is-callable-1.1.3.tgz", + "integrity": "sha1-hut1OSgF3cM69xySoO7fdO52BLI=", + "dev": true + }, + "is-ci": { + "version": "1.0.10", + "resolved": "https://registry.npmjs.org/is-ci/-/is-ci-1.0.10.tgz", + "integrity": "sha1-9zkzayYyNlBhqdSCcM1WrjNpMY4=", + "dev": true, + "requires": { + "ci-info": "1.1.1" + } + }, + "is-date-object": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/is-date-object/-/is-date-object-1.0.1.tgz", + "integrity": "sha1-mqIOtq7rv/d/vTPnTKAbM1gdOhY=", + "dev": true + }, + "is-dotfile": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/is-dotfile/-/is-dotfile-1.0.3.tgz", + "integrity": "sha1-pqLzL/0t+wT1yiXs0Pa4PPeYoeE=", + "dev": true + }, + "is-equal-shallow": { + "version": "0.1.3", + "resolved": "https://registry.npmjs.org/is-equal-shallow/-/is-equal-shallow-0.1.3.tgz", + "integrity": "sha1-IjgJj8Ih3gvPpdnqxMRdY4qhxTQ=", + "dev": true, + "requires": { + "is-primitive": "2.0.0" + } + }, + "is-extendable": { + "version": "0.1.1", + "resolved": "https://registry.npmjs.org/is-extendable/-/is-extendable-0.1.1.tgz", + "integrity": "sha1-YrEQ4omkcUGOPsNqYX1HLjAd/Ik=", + "dev": true + }, + "is-extglob": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/is-extglob/-/is-extglob-2.1.1.tgz", + "integrity": "sha1-qIwCU1eR8C7TfHahueqXc8gz+MI=", + "dev": true + }, + "is-finite": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/is-finite/-/is-finite-1.0.2.tgz", + "integrity": "sha1-zGZ3aVYCvlUO8R6LSqYwU0K20Ko=", + "dev": true, + "requires": { + "number-is-nan": "1.0.1" + } + }, + "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=", + "dev": true + }, + "is-glob": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-4.0.0.tgz", + "integrity": "sha1-lSHHaEXMJhCoUgPd8ICpWML/q8A=", + "dev": true, + "requires": { + "is-extglob": "2.1.1" + } + }, + "is-number": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/is-number/-/is-number-2.1.0.tgz", + "integrity": "sha1-Afy7s5NGOlSPL0ZszhbezknbkI8=", + "dev": true, + "requires": { + "kind-of": "3.2.2" + } + }, + "is-obj": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/is-obj/-/is-obj-1.0.1.tgz", + "integrity": "sha1-PkcprB9f3gJc19g6iW2rn09n2w8=", + "dev": true + }, + "is-path-cwd": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/is-path-cwd/-/is-path-cwd-1.0.0.tgz", + "integrity": "sha1-0iXsIxMuie3Tj9p2dHLmLmXxEG0=", + "dev": true + }, + "is-path-in-cwd": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/is-path-in-cwd/-/is-path-in-cwd-1.0.0.tgz", + "integrity": "sha1-ZHdYK4IU1gI0YJRWcAO+ip6sBNw=", + "dev": true, + "requires": { + "is-path-inside": "1.0.0" + } + }, + "is-path-inside": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/is-path-inside/-/is-path-inside-1.0.0.tgz", + "integrity": "sha1-/AbloWg/vaE95mev9xe7wQpI838=", + "dev": true, + "requires": { + "path-is-inside": "1.0.2" + } + }, + "is-posix-bracket": { + "version": "0.1.1", + "resolved": "https://registry.npmjs.org/is-posix-bracket/-/is-posix-bracket-0.1.1.tgz", + "integrity": "sha1-MzTceXdDaOkvAW5vvAqI9c1ua8Q=", + "dev": true + }, + "is-primitive": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/is-primitive/-/is-primitive-2.0.0.tgz", + "integrity": "sha1-IHurkWOEmcB7Kt8kCkGochADRXU=", + "dev": true + }, + "is-promise": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/is-promise/-/is-promise-2.1.0.tgz", + "integrity": "sha1-eaKp7OfwlugPNtKy87wWwf9L8/o=", + "dev": true + }, + "is-regex": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/is-regex/-/is-regex-1.0.4.tgz", + "integrity": "sha1-VRdIm1RwkbCTDglWVM7SXul+lJE=", + "dev": true, + "requires": { + "has": "1.0.1" + } + }, + "is-regexp": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/is-regexp/-/is-regexp-1.0.0.tgz", + "integrity": "sha1-/S2INUXEa6xaYz57mgnof6LLUGk=", + "dev": true + }, + "is-resolvable": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/is-resolvable/-/is-resolvable-1.0.0.tgz", + "integrity": "sha1-jfV8YeouPFAUCNEA+wE8+NbgzGI=", + "dev": true, + "requires": { + "tryit": "1.0.3" + } + }, + "is-stream": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/is-stream/-/is-stream-1.1.0.tgz", + "integrity": "sha1-EtSj3U5o4Lec6428hBc66A2RykQ=", + "dev": true + }, + "is-symbol": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/is-symbol/-/is-symbol-1.0.1.tgz", + "integrity": "sha1-PMWfAAJRlLarLjjbrmaJJWtmBXI=", + "dev": true + }, + "isarray": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/isarray/-/isarray-1.0.0.tgz", + "integrity": "sha1-u5NdSFgsuhaMBoNJV6VKPgcSTxE=", + "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 + }, + "isobject": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/isobject/-/isobject-2.1.0.tgz", + "integrity": "sha1-8GVWEJaj8dou9GJy+BXIQNh+DIk=", + "dev": true, + "requires": { + "isarray": "1.0.0" + } + }, + "jest-get-type": { + "version": "21.2.0", + "resolved": "https://registry.npmjs.org/jest-get-type/-/jest-get-type-21.2.0.tgz", + "integrity": "sha512-y2fFw3C+D0yjNSDp7ab1kcd6NUYfy3waPTlD8yWkAtiocJdBRQqNoRqVfMNxgj+IjT0V5cBIHJO0z9vuSSZ43Q==", + "dev": true + }, + "jest-validate": { + "version": "21.2.1", + "resolved": "https://registry.npmjs.org/jest-validate/-/jest-validate-21.2.1.tgz", + "integrity": "sha512-k4HLI1rZQjlU+EC682RlQ6oZvLrE5SCh3brseQc24vbZTxzT/k/3urar5QMCVgjadmSO7lECeGdc6YxnM3yEGg==", + "dev": true, + "requires": { + "chalk": "2.1.0", + "jest-get-type": "21.2.0", + "leven": "2.1.0", + "pretty-format": "21.2.1" + } + }, + "js-tokens": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-3.0.2.tgz", + "integrity": "sha1-mGbfOVECEw449/mWvOtlRDIJwls=", + "dev": true + }, + "js-yaml": { + "version": "3.10.0", + "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-3.10.0.tgz", + "integrity": "sha512-O2v52ffjLa9VeM43J4XocZE//WT9N0IiwDa3KSHH7Tu8CtH+1qM8SIZvnsTh6v+4yFy5KUY3BHUVwjpfAWsjIA==", + "dev": true, + "requires": { + "argparse": "1.0.9", + "esprima": "4.0.0" + } + }, + "jschardet": { + "version": "1.5.1", + "resolved": "https://registry.npmjs.org/jschardet/-/jschardet-1.5.1.tgz", + "integrity": "sha512-vE2hT1D0HLZCLLclfBSfkfTTedhVj0fubHpJBHKwwUWX0nSbhPAfk+SG9rTX95BYNmau8rGFfCeaT6T5OW1C2A==", + "dev": true + }, + "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=", + "dev": true + }, + "json-stable-stringify": { + "version": "0.0.1", + "resolved": "https://registry.npmjs.org/json-stable-stringify/-/json-stable-stringify-0.0.1.tgz", + "integrity": "sha1-YRwj6BTbN1Un34URk9tZ3Sryf0U=", + "dev": true, + "requires": { + "jsonify": "0.0.0" + } + }, + "json3": { + "version": "3.3.2", + "resolved": "https://registry.npmjs.org/json3/-/json3-3.3.2.tgz", + "integrity": "sha1-PAQ0dD35Pi9cQq7nsZvLSDV19OE=", + "dev": true + }, + "jsonify": { + "version": "0.0.0", + "resolved": "https://registry.npmjs.org/jsonify/-/jsonify-0.0.0.tgz", + "integrity": "sha1-LHS27kHZPKUbe1qu6PUDYx0lKnM=", + "dev": true + }, + "jsonparse": { + "version": "1.3.1", + "resolved": "https://registry.npmjs.org/jsonparse/-/jsonparse-1.3.1.tgz", + "integrity": "sha1-P02uSpH6wxX3EGL4UhzCOfE2YoA=", + "dev": true + }, + "kind-of": { + "version": "3.2.2", + "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-3.2.2.tgz", + "integrity": "sha1-MeohpzS6ubuw8yRm2JOupR5KPGQ=", + "dev": true, + "requires": { + "is-buffer": "1.1.5" + } + }, + "labeled-stream-splicer": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/labeled-stream-splicer/-/labeled-stream-splicer-2.0.0.tgz", + "integrity": "sha1-pS4dE4AkwAuGscDJH2d5GLiuClk=", + "dev": true, + "requires": { + "inherits": "2.0.3", + "isarray": "0.0.1", + "stream-splicer": "2.0.0" + }, + "dependencies": { + "isarray": { + "version": "0.0.1", + "resolved": "https://registry.npmjs.org/isarray/-/isarray-0.0.1.tgz", + "integrity": "sha1-ihis/Kmo9Bd+Cav8YDiTmwXR7t8=", + "dev": true + } + } + }, + "leven": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/leven/-/leven-2.1.0.tgz", + "integrity": "sha1-wuep93IJTe6dNCAq6KzORoeHVYA=", + "dev": true + }, + "levn": { + "version": "0.3.0", + "resolved": "https://registry.npmjs.org/levn/-/levn-0.3.0.tgz", + "integrity": "sha1-OwmSTt+fCDwEkP3UwLxEIeBHZO4=", + "dev": true, + "requires": { + "prelude-ls": "1.1.2", + "type-check": "0.3.2" + } + }, + "lexical-scope": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/lexical-scope/-/lexical-scope-1.2.0.tgz", + "integrity": "sha1-/Ope3HBKSzqHls3KQZw6CvryLfQ=", + "dev": true, + "requires": { + "astw": "2.2.0" + } + }, + "lint-staged": { + "version": "4.2.3", + "resolved": "https://registry.npmjs.org/lint-staged/-/lint-staged-4.2.3.tgz", + "integrity": "sha512-Ks1vMyVpp3ldeFDN9sIcHcFDh0v3X6Y6LOdT0Wl86/BSDM2R8PVcuFODkh0Dav7Ni/asUPKONfXRWZM9YO85IQ==", + "dev": true, + "requires": { + "app-root-path": "2.0.1", + "chalk": "2.1.0", + "cosmiconfig": "1.1.0", + "execa": "0.8.0", + "is-glob": "4.0.0", + "jest-validate": "21.2.1", + "listr": "0.12.0", + "lodash": "4.17.4", + "log-symbols": "2.1.0", + "minimatch": "3.0.4", + "npm-which": "3.0.1", + "p-map": "1.2.0", + "staged-git-files": "0.0.4", + "stringify-object": "3.2.1" + } + }, + "listen": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/listen/-/listen-1.0.1.tgz", + "integrity": "sha1-/u3j1ah0xTwihNPDWXpfxa/HTkM=", + "dev": true + }, + "listr": { + "version": "0.12.0", + "resolved": "https://registry.npmjs.org/listr/-/listr-0.12.0.tgz", + "integrity": "sha1-a84sD1YD+klYDqF81qAMwOX6RRo=", + "dev": true, + "requires": { + "chalk": "1.1.3", + "cli-truncate": "0.2.1", + "figures": "1.7.0", + "indent-string": "2.1.0", + "is-promise": "2.1.0", + "is-stream": "1.1.0", + "listr-silent-renderer": "1.1.1", + "listr-update-renderer": "0.2.0", + "listr-verbose-renderer": "0.4.0", + "log-symbols": "1.0.2", + "log-update": "1.0.2", + "ora": "0.2.3", + "p-map": "1.2.0", + "rxjs": "5.4.3", + "stream-to-observable": "0.1.0", + "strip-ansi": "3.0.1" + }, + "dependencies": { + "chalk": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-1.1.3.tgz", + "integrity": "sha1-qBFcVeSnAv5NFQq9OHKCKn4J/Jg=", + "dev": true, + "requires": { + "ansi-styles": "2.2.1", + "escape-string-regexp": "1.0.5", + "has-ansi": "2.0.0", + "strip-ansi": "3.0.1", + "supports-color": "2.0.0" + } + }, + "figures": { + "version": "1.7.0", + "resolved": "https://registry.npmjs.org/figures/-/figures-1.7.0.tgz", + "integrity": "sha1-y+Hjr/zxzUS4DK3+0o3Hk6lwHS4=", + "dev": true, + "requires": { + "escape-string-regexp": "1.0.5", + "object-assign": "4.1.1" + } + }, + "log-symbols": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/log-symbols/-/log-symbols-1.0.2.tgz", + "integrity": "sha1-N2/3tY6jCGoPCfrMdGF+ylAeGhg=", + "dev": true, + "requires": { + "chalk": "1.1.3" + } + }, + "strip-ansi": { + "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.1.1" + } + } + } + }, + "listr-silent-renderer": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/listr-silent-renderer/-/listr-silent-renderer-1.1.1.tgz", + "integrity": "sha1-kktaN1cVN3C/Go4/v3S4u/P5JC4=", + "dev": true + }, + "listr-update-renderer": { + "version": "0.2.0", + "resolved": "https://registry.npmjs.org/listr-update-renderer/-/listr-update-renderer-0.2.0.tgz", + "integrity": "sha1-yoDhd5tOcCZoB+ju0a1qvjmFUPk=", + "dev": true, + "requires": { + "chalk": "1.1.3", + "cli-truncate": "0.2.1", + "elegant-spinner": "1.0.1", + "figures": "1.7.0", + "indent-string": "3.2.0", + "log-symbols": "1.0.2", + "log-update": "1.0.2", + "strip-ansi": "3.0.1" + }, + "dependencies": { + "chalk": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-1.1.3.tgz", + "integrity": "sha1-qBFcVeSnAv5NFQq9OHKCKn4J/Jg=", + "dev": true, + "requires": { + "ansi-styles": "2.2.1", + "escape-string-regexp": "1.0.5", + "has-ansi": "2.0.0", + "strip-ansi": "3.0.1", + "supports-color": "2.0.0" + } + }, + "figures": { + "version": "1.7.0", + "resolved": "https://registry.npmjs.org/figures/-/figures-1.7.0.tgz", + "integrity": "sha1-y+Hjr/zxzUS4DK3+0o3Hk6lwHS4=", + "dev": true, + "requires": { + "escape-string-regexp": "1.0.5", + "object-assign": "4.1.1" + } + }, + "indent-string": { + "version": "3.2.0", + "resolved": "https://registry.npmjs.org/indent-string/-/indent-string-3.2.0.tgz", + "integrity": "sha1-Sl/W0nzDMvN+VBmlBNu4NxBckok=", + "dev": true + }, + "log-symbols": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/log-symbols/-/log-symbols-1.0.2.tgz", + "integrity": "sha1-N2/3tY6jCGoPCfrMdGF+ylAeGhg=", + "dev": true, + "requires": { + "chalk": "1.1.3" + } + }, + "strip-ansi": { + "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.1.1" + } + } + } + }, + "listr-verbose-renderer": { + "version": "0.4.0", + "resolved": "https://registry.npmjs.org/listr-verbose-renderer/-/listr-verbose-renderer-0.4.0.tgz", + "integrity": "sha1-RNwBuww0oDxXIVTU0Izemx3FYg8=", + "dev": true, + "requires": { + "chalk": "1.1.3", + "cli-cursor": "1.0.2", + "date-fns": "1.28.5", + "figures": "1.7.0" + }, + "dependencies": { + "chalk": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-1.1.3.tgz", + "integrity": "sha1-qBFcVeSnAv5NFQq9OHKCKn4J/Jg=", + "dev": true, + "requires": { + "ansi-styles": "2.2.1", + "escape-string-regexp": "1.0.5", + "has-ansi": "2.0.0", + "strip-ansi": "3.0.1", + "supports-color": "2.0.0" + } + }, + "cli-cursor": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/cli-cursor/-/cli-cursor-1.0.2.tgz", + "integrity": "sha1-ZNo/fValRBLll5S9Ytw1KV6PKYc=", + "dev": true, + "requires": { + "restore-cursor": "1.0.1" + } + }, + "figures": { + "version": "1.7.0", + "resolved": "https://registry.npmjs.org/figures/-/figures-1.7.0.tgz", + "integrity": "sha1-y+Hjr/zxzUS4DK3+0o3Hk6lwHS4=", + "dev": true, + "requires": { + "escape-string-regexp": "1.0.5", + "object-assign": "4.1.1" + } + }, + "onetime": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/onetime/-/onetime-1.1.0.tgz", + "integrity": "sha1-ofeDj4MUxRbwXs78vEzP4EtO14k=", + "dev": true + }, + "restore-cursor": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/restore-cursor/-/restore-cursor-1.0.1.tgz", + "integrity": "sha1-NGYfRohjJ/7SmRR5FSJS35LapUE=", + "dev": true, + "requires": { + "exit-hook": "1.1.1", + "onetime": "1.1.0" + } + }, + "strip-ansi": { + "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.1.1" + } + } + } + }, + "load-json-file": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/load-json-file/-/load-json-file-2.0.0.tgz", + "integrity": "sha1-eUfkIUmvgNaWy/eXvKq8/h/inKg=", + "dev": true, + "requires": { + "graceful-fs": "4.1.11", + "parse-json": "2.2.0", + "pify": "2.3.0", + "strip-bom": "3.0.0" + } + }, + "lodash": { + "version": "4.17.4", + "resolved": "https://registry.npmjs.org/lodash/-/lodash-4.17.4.tgz", + "integrity": "sha1-eCA6TRwyiuHYbcpkYONptX9AVa4=", + "dev": true + }, + "lodash._baseassign": { + "version": "3.2.0", + "resolved": "https://registry.npmjs.org/lodash._baseassign/-/lodash._baseassign-3.2.0.tgz", + "integrity": "sha1-jDigmVAPIVrQnlnxci/QxSv+Ck4=", + "dev": true, + "requires": { + "lodash._basecopy": "3.0.1", + "lodash.keys": "3.1.2" + } + }, + "lodash._basecopy": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/lodash._basecopy/-/lodash._basecopy-3.0.1.tgz", + "integrity": "sha1-jaDmqHbPNEwK2KVIghEd08XHyjY=", + "dev": true + }, + "lodash._basecreate": { + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/lodash._basecreate/-/lodash._basecreate-3.0.3.tgz", + "integrity": "sha1-G8ZhYU2qf8MRt9A78WgGoCE8+CE=", + "dev": true + }, + "lodash._getnative": { + "version": "3.9.1", + "resolved": "https://registry.npmjs.org/lodash._getnative/-/lodash._getnative-3.9.1.tgz", + "integrity": "sha1-VwvH3t5G1hzc3mh9ZdPuy6o6r/U=", + "dev": true + }, + "lodash._isiterateecall": { + "version": "3.0.9", + "resolved": "https://registry.npmjs.org/lodash._isiterateecall/-/lodash._isiterateecall-3.0.9.tgz", + "integrity": "sha1-UgOte6Ql+uhCRg5pbbnPPmqsBXw=", + "dev": true + }, + "lodash.create": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/lodash.create/-/lodash.create-3.1.1.tgz", + "integrity": "sha1-1/KEnw29p+BGgruM1yqwIkYd6+c=", + "dev": true, + "requires": { + "lodash._baseassign": "3.2.0", + "lodash._basecreate": "3.0.3", + "lodash._isiterateecall": "3.0.9" + } + }, + "lodash.isarguments": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/lodash.isarguments/-/lodash.isarguments-3.1.0.tgz", + "integrity": "sha1-L1c9hcaiQon/AGY7SRwdM4/zRYo=", + "dev": true + }, + "lodash.isarray": { + "version": "3.0.4", + "resolved": "https://registry.npmjs.org/lodash.isarray/-/lodash.isarray-3.0.4.tgz", + "integrity": "sha1-eeTriMNqgSKvhvhEqpvNhRtfu1U=", + "dev": true + }, + "lodash.keys": { + "version": "3.1.2", + "resolved": "https://registry.npmjs.org/lodash.keys/-/lodash.keys-3.1.2.tgz", + "integrity": "sha1-TbwEcrFWvlCgsoaFXRvQsMZWCYo=", + "dev": true, + "requires": { + "lodash._getnative": "3.9.1", + "lodash.isarguments": "3.1.0", + "lodash.isarray": "3.0.4" + } + }, + "lodash.memoize": { + "version": "3.0.4", + "resolved": "https://registry.npmjs.org/lodash.memoize/-/lodash.memoize-3.0.4.tgz", + "integrity": "sha1-LcvSwofLwKVcxCMovQxzYVDVPj8=", + "dev": true + }, + "log-symbols": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/log-symbols/-/log-symbols-2.1.0.tgz", + "integrity": "sha512-zLeLrzMA1A2vRF1e/0Mo+LNINzi6jzBylHj5WqvQ/WK/5WCZt8si9SyN4p9llr/HRYvVR1AoXHRHl4WTHyQAzQ==", + "dev": true, + "requires": { + "chalk": "2.1.0" + } + }, + "log-update": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/log-update/-/log-update-1.0.2.tgz", + "integrity": "sha1-GZKfZMQJPS0ucHWh2tivWcKWuNE=", + "dev": true, + "requires": { + "ansi-escapes": "1.4.0", + "cli-cursor": "1.0.2" + }, + "dependencies": { + "ansi-escapes": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/ansi-escapes/-/ansi-escapes-1.4.0.tgz", + "integrity": "sha1-06ioOzGapneTZisT52HHkRQiMG4=", + "dev": true + }, + "cli-cursor": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/cli-cursor/-/cli-cursor-1.0.2.tgz", + "integrity": "sha1-ZNo/fValRBLll5S9Ytw1KV6PKYc=", + "dev": true, + "requires": { + "restore-cursor": "1.0.1" + } + }, + "onetime": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/onetime/-/onetime-1.1.0.tgz", + "integrity": "sha1-ofeDj4MUxRbwXs78vEzP4EtO14k=", + "dev": true + }, + "restore-cursor": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/restore-cursor/-/restore-cursor-1.0.1.tgz", + "integrity": "sha1-NGYfRohjJ/7SmRR5FSJS35LapUE=", + "dev": true, + "requires": { + "exit-hook": "1.1.1", + "onetime": "1.1.0" + } + } + } + }, + "lolex": { + "version": "1.6.0", + "resolved": "https://registry.npmjs.org/lolex/-/lolex-1.6.0.tgz", + "integrity": "sha1-OpoCg0UqR9dDnnJzG54H1zhuSfY=", + "dev": true + }, + "lru-cache": { + "version": "4.1.1", + "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-4.1.1.tgz", + "integrity": "sha512-q4spe4KTfsAS1SUHLO0wz8Qiyf1+vMIAgpRYioFYDMNqKfHQbg+AVDH3i4fvpl71/P1L0dBl+fQi+P37UYf0ew==", + "dev": true, + "requires": { + "pseudomap": "1.0.2", + "yallist": "2.1.2" + } + }, + "map-stream": { + "version": "0.1.0", + "resolved": "https://registry.npmjs.org/map-stream/-/map-stream-0.1.0.tgz", + "integrity": "sha1-5WqpTEyAVaFkBKBnS3jyFffI4ZQ=", + "dev": true + }, + "md5.js": { + "version": "1.3.4", + "resolved": "https://registry.npmjs.org/md5.js/-/md5.js-1.3.4.tgz", + "integrity": "sha1-6b296UogpawYsENA/Fdk1bCdkB0=", + "dev": true, + "requires": { + "hash-base": "3.0.4", + "inherits": "2.0.3" + }, + "dependencies": { + "hash-base": { + "version": "3.0.4", + "resolved": "https://registry.npmjs.org/hash-base/-/hash-base-3.0.4.tgz", + "integrity": "sha1-X8hoaEfs1zSZQDMZprCj8/auSRg=", + "dev": true, + "requires": { + "inherits": "2.0.3", + "safe-buffer": "5.1.1" + } + } + } + }, + "memory-streams": { + "version": "0.1.2", + "resolved": "https://registry.npmjs.org/memory-streams/-/memory-streams-0.1.2.tgz", + "integrity": "sha1-Jz/3d6tg/sWZsRY1UlUoLMosUMI=", + "dev": true, + "requires": { + "readable-stream": "1.0.34" + }, + "dependencies": { + "isarray": { + "version": "0.0.1", + "resolved": "https://registry.npmjs.org/isarray/-/isarray-0.0.1.tgz", + "integrity": "sha1-ihis/Kmo9Bd+Cav8YDiTmwXR7t8=", + "dev": true + }, + "readable-stream": { + "version": "1.0.34", + "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-1.0.34.tgz", + "integrity": "sha1-Elgg40vIQtLyqq+v5MKRbuMsFXw=", + "dev": true, + "requires": { + "core-util-is": "1.0.2", + "inherits": "2.0.3", + "isarray": "0.0.1", + "string_decoder": "0.10.31" + } + }, + "string_decoder": { + "version": "0.10.31", + "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-0.10.31.tgz", + "integrity": "sha1-YuIDvEF2bGwoyfyEMB2rHFMQ+pQ=", + "dev": true + } + } + }, + "micromatch": { + "version": "2.3.11", + "resolved": "https://registry.npmjs.org/micromatch/-/micromatch-2.3.11.tgz", + "integrity": "sha1-hmd8l9FyCzY0MdBNDRUpO9OMFWU=", + "dev": true, + "requires": { + "arr-diff": "2.0.0", + "array-unique": "0.2.1", + "braces": "1.8.5", + "expand-brackets": "0.1.5", + "extglob": "0.3.2", + "filename-regex": "2.0.1", + "is-extglob": "1.0.0", + "is-glob": "2.0.1", + "kind-of": "3.2.2", + "normalize-path": "2.1.1", + "object.omit": "2.0.1", + "parse-glob": "3.0.4", + "regex-cache": "0.4.4" + }, + "dependencies": { + "is-extglob": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/is-extglob/-/is-extglob-1.0.0.tgz", + "integrity": "sha1-rEaBd8SUNAWgkvyPKXYMb/xiBsA=", + "dev": true + }, + "is-glob": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-2.0.1.tgz", + "integrity": "sha1-0Jb5JqPe1WAPP9/ZEZjLCIjC2GM=", + "dev": true, + "requires": { + "is-extglob": "1.0.0" + } + }, + "normalize-path": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/normalize-path/-/normalize-path-2.1.1.tgz", + "integrity": "sha1-GrKLVW4Zg2Oowab35vogE3/mrtk=", + "dev": true, + "requires": { + "remove-trailing-separator": "1.1.0" + } + } + } + }, + "miller-rabin": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/miller-rabin/-/miller-rabin-4.0.1.tgz", + "integrity": "sha512-115fLhvZVqWwHPbClyntxEVfVDfl9DLLTuJvq3g2O/Oxi8AiNouAHvDSzHS0viUJc+V5vm3eq91Xwqn9dp4jRA==", + "dev": true, + "requires": { + "bn.js": "4.11.8", + "brorand": "1.1.0" + } + }, + "mimic-fn": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/mimic-fn/-/mimic-fn-1.1.0.tgz", + "integrity": "sha1-5md4PZLonb00KBi1IwudYqZyrRg=", + "dev": true + }, + "min-wd": { + "version": "2.9.3", + "resolved": "https://registry.npmjs.org/min-wd/-/min-wd-2.9.3.tgz", + "integrity": "sha1-Nda8fTL2bmAZK6vf1sFnTpkvE70=", + "dev": true, + "requires": { + "brout": "1.2.0", + "listen": "1.0.1", + "resolve": "1.4.0", + "saucelabs": "1.4.0", + "source-mapper": "2.0.0", + "through2": "2.0.3" + } + }, + "minimalistic-assert": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/minimalistic-assert/-/minimalistic-assert-1.0.0.tgz", + "integrity": "sha1-cCvi3aazf0g2vLP121ZkG2Sh09M=", + "dev": true + }, + "minimalistic-crypto-utils": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/minimalistic-crypto-utils/-/minimalistic-crypto-utils-1.0.1.tgz", + "integrity": "sha1-9sAMHAsIIkblxNmd+4x8CDsrWCo=", + "dev": true + }, + "minimatch": { + "version": "3.0.4", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.0.4.tgz", + "integrity": "sha512-yJHVQEhyqPLUTgt9B83PXu6W3rx4MvvHvSUvToogpwoGDOUQ+yDrR0HRot+yOCdCO7u4hX3pWft6kWBBcqh0UA==", + "dev": true, + "requires": { + "brace-expansion": "1.1.8" + } + }, + "minimist": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.0.tgz", + "integrity": "sha1-o1AIsg9BOD7sH7kU9M1d95omQoQ=", + "dev": true + }, + "mkdirp": { + "version": "0.5.1", + "resolved": "https://registry.npmjs.org/mkdirp/-/mkdirp-0.5.1.tgz", + "integrity": "sha1-MAV0OOrGz3+MR2fzhkjWaX11yQM=", + "dev": true, + "requires": { + "minimist": "0.0.8" + }, + "dependencies": { + "minimist": { + "version": "0.0.8", + "resolved": "https://registry.npmjs.org/minimist/-/minimist-0.0.8.tgz", + "integrity": "sha1-hX/Kv8M5fSYluCKCYuhqp6ARsF0=", + "dev": true + } + } + }, + "mocaccino": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/mocaccino/-/mocaccino-2.0.0.tgz", + "integrity": "sha1-OOZqdRWWzfVaNalBELW5+z66Gxg=", + "dev": true, + "requires": { + "brout": "1.2.0", + "listen": "1.0.1", + "mocha": "3.5.3", + "resolve": "1.4.0", + "supports-color": "3.2.3", + "through2": "2.0.3" + }, + "dependencies": { + "has-flag": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-1.0.0.tgz", + "integrity": "sha1-nZ55MWXOAXoA8AQYxD+UKnsdEfo=", + "dev": true + }, + "supports-color": { + "version": "3.2.3", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-3.2.3.tgz", + "integrity": "sha1-ZawFBLOVQXHYpklGsq48u4pfVPY=", + "dev": true, + "requires": { + "has-flag": "1.0.0" + } + } + } + }, + "mocha": { + "version": "3.5.3", + "resolved": "https://registry.npmjs.org/mocha/-/mocha-3.5.3.tgz", + "integrity": "sha512-/6na001MJWEtYxHOV1WLfsmR4YIynkUEhBwzsb+fk2qmQ3iqsi258l/Q2MWHJMImAcNpZ8DEdYAK72NHoIQ9Eg==", + "dev": true, + "requires": { + "browser-stdout": "1.3.0", + "commander": "2.9.0", + "debug": "2.6.8", + "diff": "3.2.0", + "escape-string-regexp": "1.0.5", + "glob": "7.1.1", + "growl": "1.9.2", + "he": "1.1.1", + "json3": "3.3.2", + "lodash.create": "3.1.1", + "mkdirp": "0.5.1", + "supports-color": "3.1.2" + }, + "dependencies": { + "commander": { + "version": "2.9.0", + "resolved": "https://registry.npmjs.org/commander/-/commander-2.9.0.tgz", + "integrity": "sha1-nJkJQXbhIkDLItbFFGCYQA/g99Q=", + "dev": true, + "requires": { + "graceful-readlink": "1.0.1" + } + }, + "debug": { + "version": "2.6.8", + "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.8.tgz", + "integrity": "sha1-5zFTHKLt4n0YgiJCfaF4IdaP9Pw=", + "dev": true, + "requires": { + "ms": "2.0.0" + } + }, + "glob": { + "version": "7.1.1", + "resolved": "https://registry.npmjs.org/glob/-/glob-7.1.1.tgz", + "integrity": "sha1-gFIR3wT6rxxjo2ADBs31reULLsg=", + "dev": true, + "requires": { + "fs.realpath": "1.0.0", + "inflight": "1.0.6", + "inherits": "2.0.3", + "minimatch": "3.0.4", + "once": "1.4.0", + "path-is-absolute": "1.0.1" + } + }, + "has-flag": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-1.0.0.tgz", + "integrity": "sha1-nZ55MWXOAXoA8AQYxD+UKnsdEfo=", + "dev": true + }, + "supports-color": { + "version": "3.1.2", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-3.1.2.tgz", + "integrity": "sha1-cqJiiU2dQIuVbKBf83su2KbiotU=", + "dev": true, + "requires": { + "has-flag": "1.0.0" + } + } + } + }, + "mochify": { + "version": "3.3.0", + "resolved": "https://registry.npmjs.org/mochify/-/mochify-3.3.0.tgz", + "integrity": "sha512-YaLx42Nq2C10vNSIMLCP92AYYVLsF+sEXPt5Iz48VfpsKHucVpkxpsXJfQ84WAvSoBuesHmwvSJrbhX73DWjOQ==", + "dev": true, + "requires": { + "brout": "1.2.0", + "browserify": "14.4.0", + "consolify": "2.2.0", + "coverify": "1.4.1", + "glob": "7.1.2", + "min-wd": "2.9.3", + "mocaccino": "2.0.0", + "mocha": "3.5.3", + "phantomic": "1.5.2", + "resolve": "1.4.0", + "source-mapper": "2.0.0", + "subarg": "1.0.0", + "through2": "2.0.3", + "watchify": "3.9.0", + "which": "1.3.0" + } + }, + "module-deps": { + "version": "4.1.1", + "resolved": "https://registry.npmjs.org/module-deps/-/module-deps-4.1.1.tgz", + "integrity": "sha1-IyFYM/HaE/1gbMuAh7RIUty4If0=", + "dev": true, + "requires": { + "JSONStream": "1.3.1", + "browser-resolve": "1.11.2", + "cached-path-relative": "1.0.1", + "concat-stream": "1.5.2", + "defined": "1.0.0", + "detective": "4.5.0", + "duplexer2": "0.1.4", + "inherits": "2.0.3", + "parents": "1.0.1", + "readable-stream": "2.3.3", + "resolve": "1.4.0", + "stream-combiner2": "1.1.1", + "subarg": "1.0.0", + "through2": "2.0.3", + "xtend": "4.0.1" + } + }, + "ms": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz", + "integrity": "sha1-VgiurfwAvmwpAd9fmGF4jeDVl8g=", + "dev": true + }, + "mute-stream": { + "version": "0.0.7", + "resolved": "https://registry.npmjs.org/mute-stream/-/mute-stream-0.0.7.tgz", + "integrity": "sha1-MHXOk7whuPq0PhvE2n6BFe0ee6s=", + "dev": true + }, + "native-promise-only": { + "version": "0.8.1", + "resolved": "https://registry.npmjs.org/native-promise-only/-/native-promise-only-0.8.1.tgz", + "integrity": "sha1-IKMYwwy0X3H+et+/eyHJnBRy7xE=", + "dev": true + }, + "natural-compare": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/natural-compare/-/natural-compare-1.4.0.tgz", + "integrity": "sha1-Sr6/7tdUHywnrPspvbvRXI1bpPc=", + "dev": true + }, + "normalize-package-data": { + "version": "2.4.0", + "resolved": "https://registry.npmjs.org/normalize-package-data/-/normalize-package-data-2.4.0.tgz", + "integrity": "sha512-9jjUFbTPfEy3R/ad/2oNbKtW9Hgovl5O1FvFWKkKblNXoN/Oou6+9+KKohPK13Yc3/TyunyWhJp6gvRNR/PPAw==", + "dev": true, + "requires": { + "hosted-git-info": "2.5.0", + "is-builtin-module": "1.0.0", + "semver": "5.4.1", + "validate-npm-package-license": "3.0.1" + } + }, + "normalize-path": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/normalize-path/-/normalize-path-1.0.0.tgz", + "integrity": "sha1-MtDkcvkf80VwHBWoMRAY07CpA3k=", + "dev": true + }, + "npm-path": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/npm-path/-/npm-path-2.0.3.tgz", + "integrity": "sha1-Fc/04ciaONp39W9gVbJPl137K74=", + "dev": true, + "requires": { + "which": "1.3.0" + } + }, + "npm-run-all": { + "version": "4.1.1", + "resolved": "https://registry.npmjs.org/npm-run-all/-/npm-run-all-4.1.1.tgz", + "integrity": "sha512-qrmqqaJa+REbzUTIL/mHfTdgwz+gL1xUezY/ueyLa7GISZ4T3h0CH8D2r6AaZdCYN2unu7PzspP0ofpXla1ftg==", + "dev": true, + "requires": { + "ansi-styles": "3.2.0", + "chalk": "2.1.0", + "cross-spawn": "5.1.0", + "memory-streams": "0.1.2", + "minimatch": "3.0.4", + "ps-tree": "1.1.0", + "read-pkg": "2.0.0", + "shell-quote": "1.6.1", + "string.prototype.padend": "3.0.0" + }, + "dependencies": { + "ansi-styles": { + "version": "3.2.0", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-3.2.0.tgz", + "integrity": "sha512-NnSOmMEYtVR2JVMIGTzynRkkaxtiq1xnFBcdQD/DnNCYPoEPsVJhM98BDyaoNOQIi7p4okdi3E27eN7GQbsUug==", + "dev": true, + "requires": { + "color-convert": "1.9.0" + } + } + } + }, + "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, + "requires": { + "path-key": "2.0.1" + } + }, + "npm-which": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/npm-which/-/npm-which-3.0.1.tgz", + "integrity": "sha1-kiXybsOihcIJyuZ8OxGmtKtxQKo=", + "dev": true, + "requires": { + "commander": "2.11.0", + "npm-path": "2.0.3", + "which": "1.3.0" + } + }, + "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=", + "dev": true + }, + "object-assign": { + "version": "4.1.1", + "resolved": "https://registry.npmjs.org/object-assign/-/object-assign-4.1.1.tgz", + "integrity": "sha1-IQmtx5ZYh8/AXLvUQsrIv7s2CGM=", + "dev": true + }, + "object-keys": { + "version": "1.0.11", + "resolved": "https://registry.npmjs.org/object-keys/-/object-keys-1.0.11.tgz", + "integrity": "sha1-xUYBd4rVYPEULODgG8yotW0TQm0=", + "dev": true + }, + "object.omit": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/object.omit/-/object.omit-2.0.1.tgz", + "integrity": "sha1-Gpx0SCnznbuFjHbKNXmuKlTr0fo=", + "dev": true, + "requires": { + "for-own": "0.1.5", + "is-extendable": "0.1.1" + } + }, + "once": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz", + "integrity": "sha1-WDsap3WWHUsROsF9nFC6753Xa9E=", + "dev": true, + "requires": { + "wrappy": "1.0.2" + } + }, + "onetime": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/onetime/-/onetime-2.0.1.tgz", + "integrity": "sha1-BnQoIw/WdEOyeUsiu6UotoZ5YtQ=", + "dev": true, + "requires": { + "mimic-fn": "1.1.0" + } + }, + "optionator": { + "version": "0.8.2", + "resolved": "https://registry.npmjs.org/optionator/-/optionator-0.8.2.tgz", + "integrity": "sha1-NkxeQJ0/TWMB1sC0wFu6UBgK62Q=", + "dev": true, + "requires": { + "deep-is": "0.1.3", + "fast-levenshtein": "2.0.6", + "levn": "0.3.0", + "prelude-ls": "1.1.2", + "type-check": "0.3.2", + "wordwrap": "1.0.0" + } + }, + "ora": { + "version": "0.2.3", + "resolved": "https://registry.npmjs.org/ora/-/ora-0.2.3.tgz", + "integrity": "sha1-N1J9Igrc1Tw5tzVx11QVbV22V6Q=", + "dev": true, + "requires": { + "chalk": "1.1.3", + "cli-cursor": "1.0.2", + "cli-spinners": "0.1.2", + "object-assign": "4.1.1" + }, + "dependencies": { + "chalk": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-1.1.3.tgz", + "integrity": "sha1-qBFcVeSnAv5NFQq9OHKCKn4J/Jg=", + "dev": true, + "requires": { + "ansi-styles": "2.2.1", + "escape-string-regexp": "1.0.5", + "has-ansi": "2.0.0", + "strip-ansi": "3.0.1", + "supports-color": "2.0.0" + } + }, + "cli-cursor": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/cli-cursor/-/cli-cursor-1.0.2.tgz", + "integrity": "sha1-ZNo/fValRBLll5S9Ytw1KV6PKYc=", + "dev": true, + "requires": { + "restore-cursor": "1.0.1" + } + }, + "onetime": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/onetime/-/onetime-1.1.0.tgz", + "integrity": "sha1-ofeDj4MUxRbwXs78vEzP4EtO14k=", + "dev": true + }, + "restore-cursor": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/restore-cursor/-/restore-cursor-1.0.1.tgz", + "integrity": "sha1-NGYfRohjJ/7SmRR5FSJS35LapUE=", + "dev": true, + "requires": { + "exit-hook": "1.1.1", + "onetime": "1.1.0" + } + }, + "strip-ansi": { + "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.1.1" + } + } + } + }, + "os-browserify": { + "version": "0.1.2", + "resolved": "https://registry.npmjs.org/os-browserify/-/os-browserify-0.1.2.tgz", + "integrity": "sha1-ScoCk+CxlZCl9d4Qx/JlphfY/lQ=", + "dev": true + }, + "os-homedir": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/os-homedir/-/os-homedir-1.0.2.tgz", + "integrity": "sha1-/7xJiDNuDoM94MFox+8VISGqf7M=", + "dev": true + }, + "os-shim": { + "version": "0.1.3", + "resolved": "https://registry.npmjs.org/os-shim/-/os-shim-0.1.3.tgz", + "integrity": "sha1-a2LDeRz3kJ6jXtRuF2WLtBfLORc=", + "dev": true + }, + "os-tmpdir": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/os-tmpdir/-/os-tmpdir-1.0.2.tgz", + "integrity": "sha1-u+Z0BseaqFxc/sdm/lc0VV36EnQ=", + "dev": true + }, + "outpipe": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/outpipe/-/outpipe-1.1.1.tgz", + "integrity": "sha1-UM+GFjZeh+Ax4ppeyTOaPaRyX6I=", + "dev": true, + "requires": { + "shell-quote": "1.6.1" + } + }, + "p-finally": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/p-finally/-/p-finally-1.0.0.tgz", + "integrity": "sha1-P7z7FbiZpEEjs0ttzBi3JDNqLK4=", + "dev": true + }, + "p-map": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/p-map/-/p-map-1.2.0.tgz", + "integrity": "sha512-r6zKACMNhjPJMTl8KcFH4li//gkrXWfbD6feV8l6doRHlzljFWGJ2AP6iKaCJXyZmAUMOPtvbW7EXkbWO/pLEA==", + "dev": true + }, + "pako": { + "version": "0.2.9", + "resolved": "https://registry.npmjs.org/pako/-/pako-0.2.9.tgz", + "integrity": "sha1-8/dSL073gjSNqBYbrZ7P1Rv4OnU=", + "dev": true + }, + "parents": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/parents/-/parents-1.0.1.tgz", + "integrity": "sha1-/t1NK/GTp3dF/nHjcdc8MwfZx1E=", + "dev": true, + "requires": { + "path-platform": "0.11.15" + } + }, + "parse-asn1": { + "version": "5.1.0", + "resolved": "https://registry.npmjs.org/parse-asn1/-/parse-asn1-5.1.0.tgz", + "integrity": "sha1-N8T5t+06tlx0gXtfJICTf7+XxxI=", + "dev": true, + "requires": { + "asn1.js": "4.9.1", + "browserify-aes": "1.0.8", + "create-hash": "1.1.3", + "evp_bytestokey": "1.0.3", + "pbkdf2": "3.0.14" + } + }, + "parse-glob": { + "version": "3.0.4", + "resolved": "https://registry.npmjs.org/parse-glob/-/parse-glob-3.0.4.tgz", + "integrity": "sha1-ssN2z7EfNVE7rdFz7wu246OIORw=", + "dev": true, + "requires": { + "glob-base": "0.3.0", + "is-dotfile": "1.0.3", + "is-extglob": "1.0.0", + "is-glob": "2.0.1" + }, + "dependencies": { + "is-extglob": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/is-extglob/-/is-extglob-1.0.0.tgz", + "integrity": "sha1-rEaBd8SUNAWgkvyPKXYMb/xiBsA=", + "dev": true + }, + "is-glob": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-2.0.1.tgz", + "integrity": "sha1-0Jb5JqPe1WAPP9/ZEZjLCIjC2GM=", + "dev": true, + "requires": { + "is-extglob": "1.0.0" + } + } + } + }, + "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.3.1" + } + }, + "path-browserify": { + "version": "0.0.0", + "resolved": "https://registry.npmjs.org/path-browserify/-/path-browserify-0.0.0.tgz", + "integrity": "sha1-oLhwcpquIUAFt9UDLsLLuw+0RRo=", + "dev": true + }, + "path-is-absolute": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/path-is-absolute/-/path-is-absolute-1.0.1.tgz", + "integrity": "sha1-F0uSaHNVNP+8es5r9TpanhtcX18=", + "dev": true + }, + "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=", + "dev": true + }, + "path-parse": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/path-parse/-/path-parse-1.0.5.tgz", + "integrity": "sha1-PBrfhx6pzWyUMbbqK9dKD/BVxME=", + "dev": true + }, + "path-platform": { + "version": "0.11.15", + "resolved": "https://registry.npmjs.org/path-platform/-/path-platform-0.11.15.tgz", + "integrity": "sha1-6GQhf3TDaFDwhSt43Hv31KVyG/I=", + "dev": true + }, + "path-to-regexp": { + "version": "1.7.0", + "resolved": "https://registry.npmjs.org/path-to-regexp/-/path-to-regexp-1.7.0.tgz", + "integrity": "sha1-Wf3g9DW62suhA6hOnTvGTpa5k30=", + "dev": true, + "requires": { + "isarray": "0.0.1" + }, + "dependencies": { + "isarray": { + "version": "0.0.1", + "resolved": "https://registry.npmjs.org/isarray/-/isarray-0.0.1.tgz", + "integrity": "sha1-ihis/Kmo9Bd+Cav8YDiTmwXR7t8=", + "dev": true + } + } + }, + "path-type": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/path-type/-/path-type-2.0.0.tgz", + "integrity": "sha1-8BLMuEFbcJb8LaoQVMPXI4lZTHM=", + "dev": true, + "requires": { + "pify": "2.3.0" + } + }, + "pause-stream": { + "version": "0.0.11", + "resolved": "https://registry.npmjs.org/pause-stream/-/pause-stream-0.0.11.tgz", + "integrity": "sha1-/lo0sMvOErWqaitAPuLnO2AvFEU=", + "dev": true, + "requires": { + "through": "2.3.8" + } + }, + "pbkdf2": { + "version": "3.0.14", + "resolved": "https://registry.npmjs.org/pbkdf2/-/pbkdf2-3.0.14.tgz", + "integrity": "sha512-gjsZW9O34fm0R7PaLHRJmLLVfSoesxztjPjE9o6R+qtVJij90ltg1joIovN9GKrRW3t1PzhDDG3UMEMFfZ+1wA==", + "dev": true, + "requires": { + "create-hash": "1.1.3", + "create-hmac": "1.1.6", + "ripemd160": "2.0.1", + "safe-buffer": "5.1.1", + "sha.js": "2.4.9" + } + }, + "phantomic": { + "version": "1.5.2", + "resolved": "https://registry.npmjs.org/phantomic/-/phantomic-1.5.2.tgz", + "integrity": "sha1-U+GMW79vpSrE+oNdYVV/cgtK4l4=", + "dev": true, + "requires": { + "cross-spawn": "2.2.3", + "es5-shim": "4.5.9", + "source-mapper": "2.0.0" + }, + "dependencies": { + "cross-spawn": { + "version": "2.2.3", + "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-2.2.3.tgz", + "integrity": "sha1-+sViAt/T0N2GF3jy2iA79DS7ghw=", + "dev": true, + "requires": { + "cross-spawn-async": "2.2.5", + "spawn-sync": "1.0.15" + } + } + } + }, + "pify": { + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/pify/-/pify-2.3.0.tgz", + "integrity": "sha1-7RQaasBDqEnqWISY59yosVMw6Qw=", + "dev": true + }, + "pinkie": { + "version": "2.0.4", + "resolved": "https://registry.npmjs.org/pinkie/-/pinkie-2.0.4.tgz", + "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=", + "dev": true, + "requires": { + "pinkie": "2.0.4" + } + }, + "pluralize": { + "version": "7.0.0", + "resolved": "https://registry.npmjs.org/pluralize/-/pluralize-7.0.0.tgz", + "integrity": "sha512-ARhBOdzS3e41FbkW/XWrTEtukqqLoK5+Z/4UeDaLuSW+39JPeFgs4gCGqsrJHVZX0fUrx//4OF0K1CUGwlIFow==", + "dev": true + }, + "prelude-ls": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/prelude-ls/-/prelude-ls-1.1.2.tgz", + "integrity": "sha1-IZMqVJ9eUv/ZqCf1cOBL5iqX2lQ=", + "dev": true + }, + "preserve": { + "version": "0.2.0", + "resolved": "https://registry.npmjs.org/preserve/-/preserve-0.2.0.tgz", + "integrity": "sha1-gV7R9uvGWSb4ZbMQwHE7yzMVzks=", + "dev": true + }, + "pretty-format": { + "version": "21.2.1", + "resolved": "https://registry.npmjs.org/pretty-format/-/pretty-format-21.2.1.tgz", + "integrity": "sha512-ZdWPGYAnYfcVP8yKA3zFjCn8s4/17TeYH28MXuC8vTp0o21eXjbFGcOAXZEaDaOFJjc3h2qa7HQNHNshhvoh2A==", + "dev": true, + "requires": { + "ansi-regex": "3.0.0", + "ansi-styles": "3.2.0" + }, + "dependencies": { + "ansi-regex": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-3.0.0.tgz", + "integrity": "sha1-7QMXwyIGT3lGbAKWa922Bas32Zg=", + "dev": true + }, + "ansi-styles": { + "version": "3.2.0", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-3.2.0.tgz", + "integrity": "sha512-NnSOmMEYtVR2JVMIGTzynRkkaxtiq1xnFBcdQD/DnNCYPoEPsVJhM98BDyaoNOQIi7p4okdi3E27eN7GQbsUug==", + "dev": true, + "requires": { + "color-convert": "1.9.0" + } + } + } + }, + "process": { + "version": "0.11.10", + "resolved": "https://registry.npmjs.org/process/-/process-0.11.10.tgz", + "integrity": "sha1-czIwDoQBYb2j5podHZGn1LwW8YI=", + "dev": true + }, + "process-nextick-args": { + "version": "1.0.7", + "resolved": "https://registry.npmjs.org/process-nextick-args/-/process-nextick-args-1.0.7.tgz", + "integrity": "sha1-FQ4gt1ZZCtP5EJPyWk8q2L/zC6M=", + "dev": true + }, + "progress": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/progress/-/progress-2.0.0.tgz", + "integrity": "sha1-ihvjZr+Pwj2yvSPxDG/pILQ4nR8=", + "dev": true + }, + "ps-tree": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/ps-tree/-/ps-tree-1.1.0.tgz", + "integrity": "sha1-tCGyQUDWID8e08dplrRCewjowBQ=", + "dev": true, + "requires": { + "event-stream": "3.3.4" + } + }, + "pseudomap": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/pseudomap/-/pseudomap-1.0.2.tgz", + "integrity": "sha1-8FKijacOYYkX7wqKw0wa5aaChrM=", + "dev": true + }, + "public-encrypt": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/public-encrypt/-/public-encrypt-4.0.0.tgz", + "integrity": "sha1-OfaZ86RlYN1eusvKaTyvfGXBjMY=", + "dev": true, + "requires": { + "bn.js": "4.11.8", + "browserify-rsa": "4.0.1", + "create-hash": "1.1.3", + "parse-asn1": "5.1.0", + "randombytes": "2.0.5" + } + }, + "punycode": { + "version": "1.4.1", + "resolved": "https://registry.npmjs.org/punycode/-/punycode-1.4.1.tgz", + "integrity": "sha1-wNWmOycYgArY4esPpSachN1BhF4=", + "dev": true + }, + "querystring": { + "version": "0.2.0", + "resolved": "https://registry.npmjs.org/querystring/-/querystring-0.2.0.tgz", + "integrity": "sha1-sgmEkgO7Jd+CDadW50cAWHhSFiA=", + "dev": true + }, + "querystring-es3": { + "version": "0.2.1", + "resolved": "https://registry.npmjs.org/querystring-es3/-/querystring-es3-0.2.1.tgz", + "integrity": "sha1-nsYfeQSYdXB9aUFFlv2Qek1xHnM=", + "dev": true + }, + "ramda": { + "version": "0.24.1", + "resolved": "https://registry.npmjs.org/ramda/-/ramda-0.24.1.tgz", + "integrity": "sha1-w7d1UZfzW43DUCIoJixMkd22uFc=", + "dev": true + }, + "randomatic": { + "version": "1.1.7", + "resolved": "https://registry.npmjs.org/randomatic/-/randomatic-1.1.7.tgz", + "integrity": "sha512-D5JUjPyJbaJDkuAazpVnSfVkLlpeO3wDlPROTMLGKG1zMFNFRgrciKo1ltz/AzNTkqE0HzDx655QOL51N06how==", + "dev": true, + "requires": { + "is-number": "3.0.0", + "kind-of": "4.0.0" + }, + "dependencies": { + "is-number": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/is-number/-/is-number-3.0.0.tgz", + "integrity": "sha1-JP1iAaR4LPUFYcgQJ2r8fRLXEZU=", + "dev": true, + "requires": { + "kind-of": "3.2.2" + }, + "dependencies": { + "kind-of": { + "version": "3.2.2", + "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-3.2.2.tgz", + "integrity": "sha1-MeohpzS6ubuw8yRm2JOupR5KPGQ=", + "dev": true, + "requires": { + "is-buffer": "1.1.5" + } + } + } + }, + "kind-of": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-4.0.0.tgz", + "integrity": "sha1-IIE989cSkosgc3hpGkUGb65y3Vc=", + "dev": true, + "requires": { + "is-buffer": "1.1.5" + } + } + } + }, + "randombytes": { + "version": "2.0.5", + "resolved": "https://registry.npmjs.org/randombytes/-/randombytes-2.0.5.tgz", + "integrity": "sha512-8T7Zn1AhMsQ/HI1SjcCfT/t4ii3eAqco3yOcSzS4mozsOz69lHLsoMXmF9nZgnFanYscnSlUSgs8uZyKzpE6kg==", + "dev": true, + "requires": { + "safe-buffer": "5.1.1" + } + }, + "read-only-stream": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/read-only-stream/-/read-only-stream-2.0.0.tgz", + "integrity": "sha1-JyT9aoET1zdkrCiNQ4YnDB2/F/A=", + "dev": true, + "requires": { + "readable-stream": "2.3.3" + } + }, + "read-pkg": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/read-pkg/-/read-pkg-2.0.0.tgz", + "integrity": "sha1-jvHAYjxqbbDcZxPEv6xGMysjaPg=", + "dev": true, + "requires": { + "load-json-file": "2.0.0", + "normalize-package-data": "2.4.0", + "path-type": "2.0.0" + } + }, + "readable-stream": { + "version": "2.3.3", + "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-2.3.3.tgz", + "integrity": "sha512-m+qzzcn7KUxEmd1gMbchF+Y2eIUbieUaxkWtptyHywrX0rE8QEYqPC07Vuy4Wm32/xE16NcdBctb8S0Xe/5IeQ==", + "dev": true, + "requires": { + "core-util-is": "1.0.2", + "inherits": "2.0.3", + "isarray": "1.0.0", + "process-nextick-args": "1.0.7", + "safe-buffer": "5.1.1", + "string_decoder": "1.0.3", + "util-deprecate": "1.0.2" + } + }, + "readdirp": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/readdirp/-/readdirp-2.1.0.tgz", + "integrity": "sha1-TtCtBg3zBzMAxIRANz9y0cxkLXg=", + "dev": true, + "requires": { + "graceful-fs": "4.1.11", + "minimatch": "3.0.4", + "readable-stream": "2.3.3", + "set-immediate-shim": "1.0.1" + } + }, + "referee": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/referee/-/referee-1.2.0.tgz", + "integrity": "sha1-eneb7llVx4r/fYjAFhxaH0VFjJA=", + "dev": true, + "requires": { + "bane": "1.1.2", + "lodash": "3.10.1", + "samsam": "1.3.0" + }, + "dependencies": { + "lodash": { + "version": "3.10.1", + "resolved": "https://registry.npmjs.org/lodash/-/lodash-3.10.1.tgz", + "integrity": "sha1-W/Rejkm6QYnhfUgnid/RW9FAt7Y=", + "dev": true + } + } + }, + "regex-cache": { + "version": "0.4.4", + "resolved": "https://registry.npmjs.org/regex-cache/-/regex-cache-0.4.4.tgz", + "integrity": "sha512-nVIZwtCjkC9YgvWkpM55B5rBhBYRZhAaJbgcFYXXsHnbZ9UZI9nnVWYZpBlCqv9ho2eZryPnWrZGsOdPwVWXWQ==", + "dev": true, + "requires": { + "is-equal-shallow": "0.1.3" + } + }, + "remove-trailing-separator": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/remove-trailing-separator/-/remove-trailing-separator-1.1.0.tgz", + "integrity": "sha1-wkvOKig62tW8P1jg1IJJuSN52O8=", + "dev": true + }, + "repeat-element": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/repeat-element/-/repeat-element-1.1.2.tgz", + "integrity": "sha1-7wiaF40Ug7quTZPrmLT55OEdmQo=", + "dev": true + }, + "repeat-string": { + "version": "1.6.1", + "resolved": "https://registry.npmjs.org/repeat-string/-/repeat-string-1.6.1.tgz", + "integrity": "sha1-jcrkcOHIirwtYA//Sndihtp15jc=", + "dev": true + }, + "repeating": { + "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.2" + } + }, + "require-from-string": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/require-from-string/-/require-from-string-1.2.1.tgz", + "integrity": "sha1-UpyczvJzgK3+yaL5ZbZJu+5jZBg=", + "dev": true + }, + "require-uncached": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/require-uncached/-/require-uncached-1.0.3.tgz", + "integrity": "sha1-Tg1W1slmL9MeQwEcS5WqSZVUIdM=", + "dev": true, + "requires": { + "caller-path": "0.1.0", + "resolve-from": "1.0.1" + } + }, + "resolve": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/resolve/-/resolve-1.4.0.tgz", + "integrity": "sha512-aW7sVKPufyHqOmyyLzg/J+8606v5nevBgaliIlV7nUpVMsDnoBGV/cbSLNjZAg9q0Cfd/+easKVKQ8vOu8fn1Q==", + "dev": true, + "requires": { + "path-parse": "1.0.5" + } + }, + "resolve-from": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/resolve-from/-/resolve-from-1.0.1.tgz", + "integrity": "sha1-Jsv+k10a7uq7Kbw/5a6wHpPUQiY=", + "dev": true + }, + "restore-cursor": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/restore-cursor/-/restore-cursor-2.0.0.tgz", + "integrity": "sha1-n37ih/gv0ybU/RYpI9YhKe7g368=", + "dev": true, + "requires": { + "onetime": "2.0.1", + "signal-exit": "3.0.2" + } + }, + "rimraf": { + "version": "2.6.2", + "resolved": "https://registry.npmjs.org/rimraf/-/rimraf-2.6.2.tgz", + "integrity": "sha512-lreewLK/BlghmxtfH36YYVg1i8IAce4TI7oao75I1g245+6BctqTVQiBP3YUJ9C6DQOXJmkYR9X9fCLtCOJc5w==", + "dev": true, + "requires": { + "glob": "7.1.2" + } + }, + "ripemd160": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/ripemd160/-/ripemd160-2.0.1.tgz", + "integrity": "sha1-D0WEKVxTo2KK9+bXmsohzlfRxuc=", + "dev": true, + "requires": { + "hash-base": "2.0.2", + "inherits": "2.0.3" + } + }, + "run-async": { + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/run-async/-/run-async-2.3.0.tgz", + "integrity": "sha1-A3GrSuC91yDUFm19/aZP96RFpsA=", + "dev": true, + "requires": { + "is-promise": "2.1.0" + } + }, + "rx-lite": { + "version": "4.0.8", + "resolved": "https://registry.npmjs.org/rx-lite/-/rx-lite-4.0.8.tgz", + "integrity": "sha1-Cx4Rr4vESDbwSmQH6S2kJGe3lEQ=", + "dev": true + }, + "rx-lite-aggregates": { + "version": "4.0.8", + "resolved": "https://registry.npmjs.org/rx-lite-aggregates/-/rx-lite-aggregates-4.0.8.tgz", + "integrity": "sha1-dTuHqJoRyVRnxKwWJsTvxOBcZ74=", + "dev": true, + "requires": { + "rx-lite": "4.0.8" + } + }, + "rxjs": { + "version": "5.4.3", + "resolved": "https://registry.npmjs.org/rxjs/-/rxjs-5.4.3.tgz", + "integrity": "sha512-fSNi+y+P9ss+EZuV0GcIIqPUK07DEaMRUtLJvdcvMyFjc9dizuDjere+A4V7JrLGnm9iCc+nagV/4QdMTkqC4A==", + "dev": true, + "requires": { + "symbol-observable": "1.0.4" + } + }, + "safe-buffer": { + "version": "5.1.1", + "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.1.1.tgz", + "integrity": "sha512-kKvNJn6Mm93gAczWVJg7wH+wGYWNrDHdWvpUmHyEsgCtIwwo3bqPtV4tR5tuPaUhTOo/kvhVwd8XwwOllGYkbg==", + "dev": true + }, + "samsam": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/samsam/-/samsam-1.3.0.tgz", + "integrity": "sha512-1HwIYD/8UlOtFS3QO3w7ey+SdSDFE4HRNLZoZRYVQefrOY3l17epswImeB1ijgJFQJodIaHcwkp3r/myBjFVbg==", + "dev": true + }, + "saucelabs": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/saucelabs/-/saucelabs-1.4.0.tgz", + "integrity": "sha1-uTSpr52ih0s/QKrh/N5QpEZvXzg=", + "dev": true, + "requires": { + "https-proxy-agent": "1.0.0" + } + }, + "semver": { + "version": "5.4.1", + "resolved": "https://registry.npmjs.org/semver/-/semver-5.4.1.tgz", + "integrity": "sha512-WfG/X9+oATh81XtllIo/I8gOiY9EXRdv1cQdyykeXK17YcUW3EXUAi2To4pcH6nZtJPr7ZOpM5OMyWJZm+8Rsg==", + "dev": true + }, + "set-immediate-shim": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/set-immediate-shim/-/set-immediate-shim-1.0.1.tgz", + "integrity": "sha1-SysbJ+uAip+NzEgaWOXlb1mfP2E=", + "dev": true + }, + "sha.js": { + "version": "2.4.9", + "resolved": "https://registry.npmjs.org/sha.js/-/sha.js-2.4.9.tgz", + "integrity": "sha512-G8zektVqbiPHrylgew9Zg1VRB1L/DtXNUVAM6q4QLy8NE3qtHlFXTf8VLL4k1Yl6c7NMjtZUTdXV+X44nFaT6A==", + "dev": true, + "requires": { + "inherits": "2.0.3", + "safe-buffer": "5.1.1" + } + }, + "shasum": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/shasum/-/shasum-1.0.2.tgz", + "integrity": "sha1-5wEjENj0F/TetXEhUOVni4euVl8=", + "dev": true, + "requires": { + "json-stable-stringify": "0.0.1", + "sha.js": "2.4.9" + } + }, + "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 + }, + "shell-quote": { + "version": "1.6.1", + "resolved": "https://registry.npmjs.org/shell-quote/-/shell-quote-1.6.1.tgz", + "integrity": "sha1-9HgZSczkAmlxJ0MOo7PFR29IF2c=", + "dev": true, + "requires": { + "array-filter": "0.0.1", + "array-map": "0.0.0", + "array-reduce": "0.0.0", + "jsonify": "0.0.0" + } + }, + "signal-exit": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-3.0.2.tgz", + "integrity": "sha1-tf3AjxKH6hF4Yo5BXiUTK3NkbG0=", + "dev": true + }, + "sinon": { + "version": "2.4.1", + "resolved": "https://registry.npmjs.org/sinon/-/sinon-2.4.1.tgz", + "integrity": "sha512-vFTrO9Wt0ECffDYIPSP/E5bBugt0UjcBQOfQUMh66xzkyPEnhl/vM2LRZi2ajuTdkH07sA6DzrM6KvdvGIH8xw==", + "dev": true, + "requires": { + "diff": "3.2.0", + "formatio": "1.2.0", + "lolex": "1.6.0", + "native-promise-only": "0.8.1", + "path-to-regexp": "1.7.0", + "samsam": "1.3.0", + "text-encoding": "0.6.4", + "type-detect": "4.0.3" + } + }, + "slash": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/slash/-/slash-1.0.0.tgz", + "integrity": "sha1-xB8vbDn8FtHNF61LXYlhFK5HDVU=", + "dev": true + }, + "slice-ansi": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/slice-ansi/-/slice-ansi-1.0.0.tgz", + "integrity": "sha512-POqxBK6Lb3q6s047D/XsDVNPnF9Dl8JSaqe9h9lURl0OdNqy/ujDrOiIHtsqXMGbWWTIomRzAMaTyawAU//Reg==", + "dev": true, + "requires": { + "is-fullwidth-code-point": "2.0.0" + } + }, + "source-map": { + "version": "0.5.7", + "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.5.7.tgz", + "integrity": "sha1-igOdLRAh0i0eoUyA2OpGi6LvP8w=", + "dev": true + }, + "source-mapper": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/source-mapper/-/source-mapper-2.0.0.tgz", + "integrity": "sha1-Z8pIx5R1gS2HRiqnqqey9e0NNOo=", + "dev": true, + "requires": { + "convert-source-map": "1.1.3", + "source-map": "0.5.7", + "through2": "2.0.3" + } + }, + "spawn-sync": { + "version": "1.0.15", + "resolved": "https://registry.npmjs.org/spawn-sync/-/spawn-sync-1.0.15.tgz", + "integrity": "sha1-sAeZVX63+wyDdsKdROih6mfldHY=", + "dev": true, + "requires": { + "concat-stream": "1.5.2", + "os-shim": "0.1.3" + } + }, + "spdx-correct": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/spdx-correct/-/spdx-correct-1.0.2.tgz", + "integrity": "sha1-SzBz2TP/UfORLwOsVRlJikFQ20A=", + "dev": true, + "requires": { + "spdx-license-ids": "1.2.2" + } + }, + "spdx-expression-parse": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/spdx-expression-parse/-/spdx-expression-parse-1.0.4.tgz", + "integrity": "sha1-m98vIOH0DtRH++JzJmGR/O1RYmw=", + "dev": true + }, + "spdx-license-ids": { + "version": "1.2.2", + "resolved": "https://registry.npmjs.org/spdx-license-ids/-/spdx-license-ids-1.2.2.tgz", + "integrity": "sha1-yd96NCRZSt5r0RkA1ZZpbcBrrFc=", + "dev": true + }, + "split": { + "version": "0.3.3", + "resolved": "https://registry.npmjs.org/split/-/split-0.3.3.tgz", + "integrity": "sha1-zQ7qXmOiEd//frDwkcQTPi0N0o8=", + "dev": true, + "requires": { + "through": "2.3.8" + } + }, + "split2": { + "version": "0.2.1", + "resolved": "https://registry.npmjs.org/split2/-/split2-0.2.1.tgz", + "integrity": "sha1-At2smtwD7Au3jBKC7Aecpuha6QA=", + "dev": true, + "requires": { + "through2": "0.6.5" + }, + "dependencies": { + "isarray": { + "version": "0.0.1", + "resolved": "https://registry.npmjs.org/isarray/-/isarray-0.0.1.tgz", + "integrity": "sha1-ihis/Kmo9Bd+Cav8YDiTmwXR7t8=", + "dev": true + }, + "readable-stream": { + "version": "1.0.34", + "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-1.0.34.tgz", + "integrity": "sha1-Elgg40vIQtLyqq+v5MKRbuMsFXw=", + "dev": true, + "requires": { + "core-util-is": "1.0.2", + "inherits": "2.0.3", + "isarray": "0.0.1", + "string_decoder": "0.10.31" + } + }, + "string_decoder": { + "version": "0.10.31", + "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-0.10.31.tgz", + "integrity": "sha1-YuIDvEF2bGwoyfyEMB2rHFMQ+pQ=", + "dev": true + }, + "through2": { + "version": "0.6.5", + "resolved": "https://registry.npmjs.org/through2/-/through2-0.6.5.tgz", + "integrity": "sha1-QaucZ7KdVyCQcUEOHXp6lozTrUg=", + "dev": true, + "requires": { + "readable-stream": "1.0.34", + "xtend": "4.0.1" + } + } + } + }, + "sprintf-js": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/sprintf-js/-/sprintf-js-1.0.3.tgz", + "integrity": "sha1-BOaSb2YolTVPPdAVIDYzuFcpfiw=", + "dev": true + }, + "staged-git-files": { + "version": "0.0.4", + "resolved": "https://registry.npmjs.org/staged-git-files/-/staged-git-files-0.0.4.tgz", + "integrity": "sha1-15fhtVHKemOd7AI33G60u5vhfTU=", + "dev": true + }, + "stream-browserify": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/stream-browserify/-/stream-browserify-2.0.1.tgz", + "integrity": "sha1-ZiZu5fm9uZQKTkUUyvtDu3Hlyds=", + "dev": true, + "requires": { + "inherits": "2.0.3", + "readable-stream": "2.3.3" + } + }, + "stream-combiner": { + "version": "0.0.4", + "resolved": "https://registry.npmjs.org/stream-combiner/-/stream-combiner-0.0.4.tgz", + "integrity": "sha1-TV5DPBhSYd3mI8o/RMWGvPXErRQ=", + "dev": true, + "requires": { + "duplexer": "0.1.1" + } + }, + "stream-combiner2": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/stream-combiner2/-/stream-combiner2-1.1.1.tgz", + "integrity": "sha1-+02KFCDqNidk4hrUeAOXvry0HL4=", + "dev": true, + "requires": { + "duplexer2": "0.1.4", + "readable-stream": "2.3.3" + } + }, + "stream-http": { + "version": "2.7.2", + "resolved": "https://registry.npmjs.org/stream-http/-/stream-http-2.7.2.tgz", + "integrity": "sha512-c0yTD2rbQzXtSsFSVhtpvY/vS6u066PcXOX9kBB3mSO76RiUQzL340uJkGBWnlBg4/HZzqiUXtaVA7wcRcJgEw==", + "dev": true, + "requires": { + "builtin-status-codes": "3.0.0", + "inherits": "2.0.3", + "readable-stream": "2.3.3", + "to-arraybuffer": "1.0.1", + "xtend": "4.0.1" + } + }, + "stream-splicer": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/stream-splicer/-/stream-splicer-2.0.0.tgz", + "integrity": "sha1-G2O+Q4oTPktnHMGTUZdgAXWRDYM=", + "dev": true, + "requires": { + "inherits": "2.0.3", + "readable-stream": "2.3.3" + } + }, + "stream-to-observable": { + "version": "0.1.0", + "resolved": "https://registry.npmjs.org/stream-to-observable/-/stream-to-observable-0.1.0.tgz", + "integrity": "sha1-Rb8dny19wJvtgfHDB8Qw5ouEz/4=", + "dev": true + }, + "string-width": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/string-width/-/string-width-2.1.1.tgz", + "integrity": "sha512-nOqH59deCq9SRHlxq1Aw85Jnt4w6KvLKqWVik6oA9ZklXLNIOlqg4F2yrT1MVaTjAqvVwdfeZ7w7aCvJD7ugkw==", + "dev": true, + "requires": { + "is-fullwidth-code-point": "2.0.0", + "strip-ansi": "4.0.0" + } + }, + "string.prototype.padend": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/string.prototype.padend/-/string.prototype.padend-3.0.0.tgz", + "integrity": "sha1-86rvfBcZ8XDF6rHDK/eA2W4h8vA=", + "dev": true, + "requires": { + "define-properties": "1.1.2", + "es-abstract": "1.9.0", + "function-bind": "1.1.1" + } + }, + "string_decoder": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.0.3.tgz", + "integrity": "sha512-4AH6Z5fzNNBcH+6XDMfA/BTt87skxqJlO0lAh3Dker5zThcAxG6mKz+iGu308UKoPPQ8Dcqx/4JhujzltRa+hQ==", + "dev": true, + "requires": { + "safe-buffer": "5.1.1" + } + }, + "stringify-object": { + "version": "3.2.1", + "resolved": "https://registry.npmjs.org/stringify-object/-/stringify-object-3.2.1.tgz", + "integrity": "sha512-jPcQYw/52HUPP8uOE4kkjxl5bB9LfHkKCTptIk3qw7ozP5XMIMlHMLjt00GGSwW6DJAf/njY5EU6Vpwl4LlBKQ==", + "dev": true, + "requires": { + "get-own-enumerable-property-symbols": "2.0.1", + "is-obj": "1.0.1", + "is-regexp": "1.0.0" + } + }, + "strip-ansi": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-4.0.0.tgz", + "integrity": "sha1-qEeQIusaw2iocTibY1JixQXuNo8=", + "dev": true, + "requires": { + "ansi-regex": "3.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=", + "dev": true + } + } + }, + "strip-bom": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/strip-bom/-/strip-bom-3.0.0.tgz", + "integrity": "sha1-IzTBjpx1n3vdVv3vfprj1YjmjtM=", + "dev": true + }, + "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": "2.0.0", + "resolved": "https://registry.npmjs.org/strip-indent/-/strip-indent-2.0.0.tgz", + "integrity": "sha1-XvjbKV0B5u1sv3qrlpmNeCJSe2g=", + "dev": true + }, + "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=", + "dev": true + }, + "subarg": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/subarg/-/subarg-1.0.0.tgz", + "integrity": "sha1-9izxdYHplrSPyWVpn1TAauJouNI=", + "dev": true, + "requires": { + "minimist": "1.2.0" + } + }, + "supports-color": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-2.0.0.tgz", + "integrity": "sha1-U10EXOa2Nj+kARcIRimZXp3zJMc=", + "dev": true + }, + "symbol-observable": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/symbol-observable/-/symbol-observable-1.0.4.tgz", + "integrity": "sha1-Kb9hXUqnEhvdiYsi1LP5vE4qoD0=", + "dev": true + }, + "syntax-error": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/syntax-error/-/syntax-error-1.3.0.tgz", + "integrity": "sha1-HtkmbE1AvnXcVb+bsct3Biu5bKE=", + "dev": true, + "requires": { + "acorn": "4.0.13" + } + }, + "table": { + "version": "4.0.2", + "resolved": "https://registry.npmjs.org/table/-/table-4.0.2.tgz", + "integrity": "sha512-UUkEAPdSGxtRpiV9ozJ5cMTtYiqz7Ni1OGqLXRCynrvzdtR1p+cfOWe2RJLwvUG8hNanaSRjecIqwOjqeatDsA==", + "dev": true, + "requires": { + "ajv": "5.2.3", + "ajv-keywords": "2.1.0", + "chalk": "2.1.0", + "lodash": "4.17.4", + "slice-ansi": "1.0.0", + "string-width": "2.1.1" + } + }, + "text-encoding": { + "version": "0.6.4", + "resolved": "https://registry.npmjs.org/text-encoding/-/text-encoding-0.6.4.tgz", + "integrity": "sha1-45mpgiV6J22uQou5KEXLcb3CbRk=", + "dev": true + }, + "text-table": { + "version": "0.2.0", + "resolved": "https://registry.npmjs.org/text-table/-/text-table-0.2.0.tgz", + "integrity": "sha1-f17oI66AUgfACvLfSoTsP8+lcLQ=", + "dev": true + }, + "through": { + "version": "2.3.8", + "resolved": "https://registry.npmjs.org/through/-/through-2.3.8.tgz", + "integrity": "sha1-DdTJ/6q8NXlgsbckEV1+Doai4fU=", + "dev": true + }, + "through2": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/through2/-/through2-2.0.3.tgz", + "integrity": "sha1-AARWmzfHx0ujnEPzzteNGtlBQL4=", + "dev": true, + "requires": { + "readable-stream": "2.3.3", + "xtend": "4.0.1" + } + }, + "timers-browserify": { + "version": "1.4.2", + "resolved": "https://registry.npmjs.org/timers-browserify/-/timers-browserify-1.4.2.tgz", + "integrity": "sha1-ycWLV1voQHN1y14kYtrO50NZ9B0=", + "dev": true, + "requires": { + "process": "0.11.10" + } + }, + "tmp": { + "version": "0.0.33", + "resolved": "https://registry.npmjs.org/tmp/-/tmp-0.0.33.tgz", + "integrity": "sha512-jRCJlojKnZ3addtTOjdIqoRuPEKBvNXcGYqzO6zWZX8KfKEpnGY5jfggJQ3EjKuu8D4bJRr0y+cYJFmYbImXGw==", + "dev": true, + "requires": { + "os-tmpdir": "1.0.2" + } + }, + "to-arraybuffer": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/to-arraybuffer/-/to-arraybuffer-1.0.1.tgz", + "integrity": "sha1-fSKbH8xjfkZsoIEYCDanqr/4P0M=", + "dev": true + }, + "tryit": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/tryit/-/tryit-1.0.3.tgz", + "integrity": "sha1-OTvnMKlEb9Hq1tpZoBQwjzbCics=", + "dev": true + }, + "tty-browserify": { + "version": "0.0.0", + "resolved": "https://registry.npmjs.org/tty-browserify/-/tty-browserify-0.0.0.tgz", + "integrity": "sha1-oVe6QC2iTpv5V/mqadUk7tQpAaY=", + "dev": true + }, + "type-check": { + "version": "0.3.2", + "resolved": "https://registry.npmjs.org/type-check/-/type-check-0.3.2.tgz", + "integrity": "sha1-WITKtRLPHTVeP7eE8wgEsrUg23I=", + "dev": true, + "requires": { + "prelude-ls": "1.1.2" + } + }, + "type-detect": { + "version": "4.0.3", + "resolved": "https://registry.npmjs.org/type-detect/-/type-detect-4.0.3.tgz", + "integrity": "sha1-Dj8mcLRAmbC0bChNE2p+9Jx0wuo=", + "dev": true + }, + "typedarray": { + "version": "0.0.6", + "resolved": "https://registry.npmjs.org/typedarray/-/typedarray-0.0.6.tgz", + "integrity": "sha1-hnrHTjhkGHsdPUfZlqeOxciDB3c=", + "dev": true + }, + "umd": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/umd/-/umd-3.0.1.tgz", + "integrity": "sha1-iuVW4RAR9jwllnCKiDclnwGz1g4=", + "dev": true + }, + "url": { + "version": "0.11.0", + "resolved": "https://registry.npmjs.org/url/-/url-0.11.0.tgz", + "integrity": "sha1-ODjpfPxgUh63PFJajlW/3Z4uKPE=", + "dev": true, + "requires": { + "punycode": "1.3.2", + "querystring": "0.2.0" + }, + "dependencies": { + "punycode": { + "version": "1.3.2", + "resolved": "https://registry.npmjs.org/punycode/-/punycode-1.3.2.tgz", + "integrity": "sha1-llOgNvt8HuQjQvIyXM7v6jkmxI0=", + "dev": true + } + } + }, + "util": { + "version": "0.10.3", + "resolved": "https://registry.npmjs.org/util/-/util-0.10.3.tgz", + "integrity": "sha1-evsa/lCAUkZInj23/g7TeTNqwPk=", + "dev": true, + "requires": { + "inherits": "2.0.1" + }, + "dependencies": { + "inherits": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.1.tgz", + "integrity": "sha1-sX0I0ya0Qj5Wjv9xn5GwscvfafE=", + "dev": true + } + } + }, + "util-deprecate": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/util-deprecate/-/util-deprecate-1.0.2.tgz", + "integrity": "sha1-RQ1Nyfpw3nMnYvvS1KKJgUGaDM8=", + "dev": true + }, + "validate-npm-package-license": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/validate-npm-package-license/-/validate-npm-package-license-3.0.1.tgz", + "integrity": "sha1-KAS6vnEq0zeUWaz74kdGqywwP7w=", + "dev": true, + "requires": { + "spdx-correct": "1.0.2", + "spdx-expression-parse": "1.0.4" + } + }, + "vm-browserify": { + "version": "0.0.4", + "resolved": "https://registry.npmjs.org/vm-browserify/-/vm-browserify-0.0.4.tgz", + "integrity": "sha1-XX6kW7755Kb/ZflUOOCofDV9WnM=", + "dev": true, + "requires": { + "indexof": "0.0.1" + } + }, + "watchify": { + "version": "3.9.0", + "resolved": "https://registry.npmjs.org/watchify/-/watchify-3.9.0.tgz", + "integrity": "sha1-8HX9LoqGrN6Eztum5cKgvt1SPZ4=", + "dev": true, + "requires": { + "anymatch": "1.3.2", + "browserify": "14.4.0", + "chokidar": "1.7.0", + "defined": "1.0.0", + "outpipe": "1.1.1", + "through2": "2.0.3", + "xtend": "4.0.1" + } + }, + "which": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/which/-/which-1.3.0.tgz", + "integrity": "sha512-xcJpopdamTuY5duC/KnTTNBraPK54YwpenP4lzxU8H91GudWpFv38u0CKjclE1Wi2EH2EDz5LRcHcKbCIzqGyg==", + "dev": true, + "requires": { + "isexe": "2.0.0" + } + }, + "wordwrap": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/wordwrap/-/wordwrap-1.0.0.tgz", + "integrity": "sha1-J1hIEIkUVqQXHI0CJkQa3pDLyus=", + "dev": true + }, + "wrappy": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz", + "integrity": "sha1-tSQ9jz7BqjXxNkYFvA0QNuMKtp8=", + "dev": true + }, + "write": { + "version": "0.2.1", + "resolved": "https://registry.npmjs.org/write/-/write-0.2.1.tgz", + "integrity": "sha1-X8A4KOJkzqP+kUVUdvejxWbLB1c=", + "dev": true, + "requires": { + "mkdirp": "0.5.1" + } + }, + "xtend": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/xtend/-/xtend-4.0.1.tgz", + "integrity": "sha1-pcbVMr5lbiPbgg77lDofBJmNY68=", + "dev": true + }, + "yallist": { + "version": "2.1.2", + "resolved": "https://registry.npmjs.org/yallist/-/yallist-2.1.2.tgz", + "integrity": "sha1-HBH5IY8HYImkfdUS+TxmmaaoHVI=", + "dev": true + } + } +} diff -Nru node-lolex-1.5.1/Readme.md node-lolex-2.2.0/Readme.md --- node-lolex-1.5.1/Readme.md 2016-07-26 15:17:13.000000000 +0000 +++ node-lolex-2.2.0/Readme.md 2017-11-07 16:28:37.000000000 +0000 @@ -1,31 +1,28 @@ # Lolex [![Build Status](https://secure.travis-ci.org/sinonjs/lolex.png)](http://travis-ci.org/sinonjs/lolex) [![bitHound Overall Score](https://www.bithound.io/github/sinonjs/lolex/badges/score.svg)](https://www.bithound.io/github/sinonjs/lolex) -JavaScript implementation of the timer APIs; `setTimeout`, `clearTimeout`, -`setImmediate`, `clearImmediate`, `setInterval` and `clearInterval`, along with -a clock instance that controls the flow of time. Lolex also provides a `Date` -implementation that gets its time from the clock. +JavaScript implementation of the timer APIs; `setTimeout`, `clearTimeout`, `setImmediate`, `clearImmediate`, `setInterval`, `clearInterval`, `requestAnimationFrame`, and `clearAnimationFrame`, along with a clock instance that controls the flow of time. Lolex also provides a `Date` implementation that gets its time from the clock. + +In addition in browser environment lolex provides a `performance` implementation that gets its time from the clock. In Node environments lolex provides a `nextTick` implementation that is synchronized with the clock - and a `process.hrtime` shim that works with the clock. Lolex can be used to simulate passing time in automated tests and other situations where you want the scheduling semantics, but don't want to actually -wait. Lolex is extracted from [Sinon.JS](https://github.com/sinonjs/sinon.js). +wait (however, from version 2.0 lolex supports those of you who would like to wait too). + +Lolex is extracted from [Sinon.JS](https://github.com/sinonjs/sinon.js). ## Installation -Lolex can be installed using `npm`: +Lolex can be used in both Node and browser environments. Installation is as easy as ```sh npm install lolex ``` -If you want to use Lolex in a browser, you have a few options. Releases are -hosted on the [sinonjs.org](http://sinonjs.org/download/) website. You can also -get the node module and build a file for the browser using browserify: +If you want to use Lolex in a browser you can use [the pre-built +version](https://github.com/sinonjs/lolex/blob/master/lolex.js) available in the repo +and the npm package. Using npm you only need to reference `./node_modules/lolex/lolex.js` in your `