From 9409542664ff20be4e127409e70c077657fbbae0 Mon Sep 17 00:00:00 2001 From: RogeredBacon Date: Thu, 7 Sep 2017 15:46:42 +0000 Subject: [PATCH 1/9] Added cannon.js and applyed rigidbody to obj1 as a test; semi-working. #5 --- package-lock.json | 3 + package.json | 3 +- public/js/bundle.js | 14611 +++++++++++++++++++++++++++++++++++++++++- src/animate.js | 7 +- src/cubes.js | 6 +- src/init/init.js | 44 +- src/letsMove.js | 9 +- 7 files changed, 14638 insertions(+), 45 deletions(-) diff --git a/package-lock.json b/package-lock.json index dc8f3a0..f1616c5 100644 --- a/package-lock.json +++ b/package-lock.json @@ -1070,6 +1070,9 @@ "integrity": "sha1-r6uWJikQp/M8GaV3WCXGnzTjUMo=", "dev": true }, + "cannon": { + "version": "github:schteppe/cannon.js#569730f94a1d9da47967a24fad0323ef7d5b4119" + }, "chalk": { "version": "1.1.3", "resolved": "https://registry.npmjs.org/chalk/-/chalk-1.1.3.tgz", diff --git a/package.json b/package.json index a3cba32..d8aff9f 100644 --- a/package.json +++ b/package.json @@ -29,7 +29,8 @@ "three": "^0.87.1", "three-mtl-loader": "^1.0.1", "three-obj-loader": "^1.1.2", - "three-pointerlock": "0.0.2" + "three-pointerlock": "0.0.2", + "cannon": "github:schteppe/cannon.js" }, "devDependencies": { "babel-preset-es2015": "^6.24.1", diff --git a/public/js/bundle.js b/public/js/bundle.js index d4bf4c4..33c4c3a 100644 --- a/public/js/bundle.js +++ b/public/js/bundle.js @@ -1,4 +1,14532 @@ (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 u.x){ u.x = p.x; } + if(p.x < l.x){ l.x = p.x; } + if(p.y > u.y){ u.y = p.y; } + if(p.y < l.y){ l.y = p.y; } + if(p.z > u.z){ u.z = p.z; } + if(p.z < l.z){ l.z = p.z; } + } + + // Add offset + if (position) { + position.vadd(l, l); + position.vadd(u, u); + } + + if(skinSize){ + l.x -= skinSize; + l.y -= skinSize; + l.z -= skinSize; + u.x += skinSize; + u.y += skinSize; + u.z += skinSize; + } + + return this; +}; + +/** + * Copy bounds from an AABB to this AABB + * @method copy + * @param {AABB} aabb Source to copy from + * @return {AABB} The this object, for chainability + */ +AABB.prototype.copy = function(aabb){ + this.lowerBound.copy(aabb.lowerBound); + this.upperBound.copy(aabb.upperBound); + return this; +}; + +/** + * Clone an AABB + * @method clone + */ +AABB.prototype.clone = function(){ + return new AABB().copy(this); +}; + +/** + * Extend this AABB so that it covers the given AABB too. + * @method extend + * @param {AABB} aabb + */ +AABB.prototype.extend = function(aabb){ + this.lowerBound.x = Math.min(this.lowerBound.x, aabb.lowerBound.x); + this.upperBound.x = Math.max(this.upperBound.x, aabb.upperBound.x); + this.lowerBound.y = Math.min(this.lowerBound.y, aabb.lowerBound.y); + this.upperBound.y = Math.max(this.upperBound.y, aabb.upperBound.y); + this.lowerBound.z = Math.min(this.lowerBound.z, aabb.lowerBound.z); + this.upperBound.z = Math.max(this.upperBound.z, aabb.upperBound.z); +}; + +/** + * Returns true if the given AABB overlaps this AABB. + * @method overlaps + * @param {AABB} aabb + * @return {Boolean} + */ +AABB.prototype.overlaps = function(aabb){ + var l1 = this.lowerBound, + u1 = this.upperBound, + l2 = aabb.lowerBound, + u2 = aabb.upperBound; + + // l2 u2 + // |---------| + // |--------| + // l1 u1 + + var overlapsX = ((l2.x <= u1.x && u1.x <= u2.x) || (l1.x <= u2.x && u2.x <= u1.x)); + var overlapsY = ((l2.y <= u1.y && u1.y <= u2.y) || (l1.y <= u2.y && u2.y <= u1.y)); + var overlapsZ = ((l2.z <= u1.z && u1.z <= u2.z) || (l1.z <= u2.z && u2.z <= u1.z)); + + return overlapsX && overlapsY && overlapsZ; +}; + +// Mostly for debugging +AABB.prototype.volume = function(){ + var l = this.lowerBound, + u = this.upperBound; + return (u.x - l.x) * (u.y - l.y) * (u.z - l.z); +}; + + +/** + * Returns true if the given AABB is fully contained in this AABB. + * @method contains + * @param {AABB} aabb + * @return {Boolean} + */ +AABB.prototype.contains = function(aabb){ + var l1 = this.lowerBound, + u1 = this.upperBound, + l2 = aabb.lowerBound, + u2 = aabb.upperBound; + + // l2 u2 + // |---------| + // |---------------| + // l1 u1 + + return ( + (l1.x <= l2.x && u1.x >= u2.x) && + (l1.y <= l2.y && u1.y >= u2.y) && + (l1.z <= l2.z && u1.z >= u2.z) + ); +}; + +/** + * @method getCorners + * @param {Vec3} a + * @param {Vec3} b + * @param {Vec3} c + * @param {Vec3} d + * @param {Vec3} e + * @param {Vec3} f + * @param {Vec3} g + * @param {Vec3} h + */ +AABB.prototype.getCorners = function(a, b, c, d, e, f, g, h){ + var l = this.lowerBound, + u = this.upperBound; + + a.copy(l); + b.set( u.x, l.y, l.z ); + c.set( u.x, u.y, l.z ); + d.set( l.x, u.y, u.z ); + e.set( u.x, l.y, l.z ); + f.set( l.x, u.y, l.z ); + g.set( l.x, l.y, u.z ); + h.copy(u); +}; + +var transformIntoFrame_corners = [ + new Vec3(), + new Vec3(), + new Vec3(), + new Vec3(), + new Vec3(), + new Vec3(), + new Vec3(), + new Vec3() +]; + +/** + * Get the representation of an AABB in another frame. + * @method toLocalFrame + * @param {Transform} frame + * @param {AABB} target + * @return {AABB} The "target" AABB object. + */ +AABB.prototype.toLocalFrame = function(frame, target){ + + var corners = transformIntoFrame_corners; + var a = corners[0]; + var b = corners[1]; + var c = corners[2]; + var d = corners[3]; + var e = corners[4]; + var f = corners[5]; + var g = corners[6]; + var h = corners[7]; + + // Get corners in current frame + this.getCorners(a, b, c, d, e, f, g, h); + + // Transform them to new local frame + for(var i=0; i !== 8; i++){ + var corner = corners[i]; + frame.pointToLocal(corner, corner); + } + + return target.setFromPoints(corners); +}; + +/** + * Get the representation of an AABB in the global frame. + * @method toWorldFrame + * @param {Transform} frame + * @param {AABB} target + * @return {AABB} The "target" AABB object. + */ +AABB.prototype.toWorldFrame = function(frame, target){ + + var corners = transformIntoFrame_corners; + var a = corners[0]; + var b = corners[1]; + var c = corners[2]; + var d = corners[3]; + var e = corners[4]; + var f = corners[5]; + var g = corners[6]; + var h = corners[7]; + + // Get corners in current frame + this.getCorners(a, b, c, d, e, f, g, h); + + // Transform them to new local frame + for(var i=0; i !== 8; i++){ + var corner = corners[i]; + frame.pointToWorld(corner, corner); + } + + return target.setFromPoints(corners); +}; + +/** + * Check if the AABB is hit by a ray. + * @param {Ray} ray + * @return {number} + */ +AABB.prototype.overlapsRay = function(ray){ + var t = 0; + + // ray.direction is unit direction vector of ray + var dirFracX = 1 / ray._direction.x; + var dirFracY = 1 / ray._direction.y; + var dirFracZ = 1 / ray._direction.z; + + // this.lowerBound is the corner of AABB with minimal coordinates - left bottom, rt is maximal corner + var t1 = (this.lowerBound.x - ray.from.x) * dirFracX; + var t2 = (this.upperBound.x - ray.from.x) * dirFracX; + var t3 = (this.lowerBound.y - ray.from.y) * dirFracY; + var t4 = (this.upperBound.y - ray.from.y) * dirFracY; + var t5 = (this.lowerBound.z - ray.from.z) * dirFracZ; + var t6 = (this.upperBound.z - ray.from.z) * dirFracZ; + + // var tmin = Math.max(Math.max(Math.min(t1, t2), Math.min(t3, t4))); + // var tmax = Math.min(Math.min(Math.max(t1, t2), Math.max(t3, t4))); + var tmin = Math.max(Math.max(Math.min(t1, t2), Math.min(t3, t4)), Math.min(t5, t6)); + var tmax = Math.min(Math.min(Math.max(t1, t2), Math.max(t3, t4)), Math.max(t5, t6)); + + // if tmax < 0, ray (line) is intersecting AABB, but whole AABB is behing us + if (tmax < 0){ + //t = tmax; + return false; + } + + // if tmin > tmax, ray doesn't intersect AABB + if (tmin > tmax){ + //t = tmax; + return false; + } + + return true; +}; +},{"../math/Vec3":31,"../utils/Utils":54}],4:[function(require,module,exports){ +module.exports = ArrayCollisionMatrix; + +/** + * Collision "matrix". It's actually a triangular-shaped array of whether two bodies are touching this step, for reference next step + * @class ArrayCollisionMatrix + * @constructor + */ +function ArrayCollisionMatrix() { + + /** + * The matrix storage + * @property matrix + * @type {Array} + */ + this.matrix = []; +} + +/** + * Get an element + * @method get + * @param {Number} i + * @param {Number} j + * @return {Number} + */ +ArrayCollisionMatrix.prototype.get = function(i, j) { + i = i.index; + j = j.index; + if (j > i) { + var temp = j; + j = i; + i = temp; + } + return this.matrix[(i*(i + 1)>>1) + j-1]; +}; + +/** + * Set an element + * @method set + * @param {Number} i + * @param {Number} j + * @param {Number} value + */ +ArrayCollisionMatrix.prototype.set = function(i, j, value) { + i = i.index; + j = j.index; + if (j > i) { + var temp = j; + j = i; + i = temp; + } + this.matrix[(i*(i + 1)>>1) + j-1] = value ? 1 : 0; +}; + +/** + * Sets all elements to zero + * @method reset + */ +ArrayCollisionMatrix.prototype.reset = function() { + for (var i=0, l=this.matrix.length; i!==l; i++) { + this.matrix[i]=0; + } +}; + +/** + * Sets the max number of objects + * @method setNumObjects + * @param {Number} n + */ +ArrayCollisionMatrix.prototype.setNumObjects = function(n) { + this.matrix.length = n*(n-1)>>1; +}; + +},{}],5:[function(require,module,exports){ +var Body = require('../objects/Body'); +var Vec3 = require('../math/Vec3'); +var Quaternion = require('../math/Quaternion'); +var Shape = require('../shapes/Shape'); +var Plane = require('../shapes/Plane'); + +module.exports = Broadphase; + +/** + * Base class for broadphase implementations + * @class Broadphase + * @constructor + * @author schteppe + */ +function Broadphase(){ + /** + * The world to search for collisions in. + * @property world + * @type {World} + */ + this.world = null; + + /** + * If set to true, the broadphase uses bounding boxes for intersection test, else it uses bounding spheres. + * @property useBoundingBoxes + * @type {Boolean} + */ + this.useBoundingBoxes = false; + + /** + * Set to true if the objects in the world moved. + * @property {Boolean} dirty + */ + this.dirty = true; +} + +/** + * Get the collision pairs from the world + * @method collisionPairs + * @param {World} world The world to search in + * @param {Array} p1 Empty array to be filled with body objects + * @param {Array} p2 Empty array to be filled with body objects + */ +Broadphase.prototype.collisionPairs = function(world,p1,p2){ + throw new Error("collisionPairs not implemented for this BroadPhase class!"); +}; + +/** + * Check if a body pair needs to be intersection tested at all. + * @method needBroadphaseCollision + * @param {Body} bodyA + * @param {Body} bodyB + * @return {bool} + */ +Broadphase.prototype.needBroadphaseCollision = function(bodyA,bodyB){ + + // Check collision filter masks + if( (bodyA.collisionFilterGroup & bodyB.collisionFilterMask)===0 || (bodyB.collisionFilterGroup & bodyA.collisionFilterMask)===0){ + return false; + } + + // Check types + if(((bodyA.type & Body.STATIC)!==0 || bodyA.sleepState === Body.SLEEPING) && + ((bodyB.type & Body.STATIC)!==0 || bodyB.sleepState === Body.SLEEPING)) { + // Both bodies are static or sleeping. Skip. + return false; + } + + return true; +}; + +/** + * Check if the bounding volumes of two bodies intersect. + * @method intersectionTest + * @param {Body} bodyA + * @param {Body} bodyB + * @param {array} pairs1 + * @param {array} pairs2 + */ +Broadphase.prototype.intersectionTest = function(bodyA, bodyB, pairs1, pairs2){ + if(this.useBoundingBoxes){ + this.doBoundingBoxBroadphase(bodyA,bodyB,pairs1,pairs2); + } else { + this.doBoundingSphereBroadphase(bodyA,bodyB,pairs1,pairs2); + } +}; + +/** + * Check if the bounding spheres of two bodies are intersecting. + * @method doBoundingSphereBroadphase + * @param {Body} bodyA + * @param {Body} bodyB + * @param {Array} pairs1 bodyA is appended to this array if intersection + * @param {Array} pairs2 bodyB is appended to this array if intersection + */ +var Broadphase_collisionPairs_r = new Vec3(), // Temp objects + Broadphase_collisionPairs_normal = new Vec3(), + Broadphase_collisionPairs_quat = new Quaternion(), + Broadphase_collisionPairs_relpos = new Vec3(); +Broadphase.prototype.doBoundingSphereBroadphase = function(bodyA,bodyB,pairs1,pairs2){ + var r = Broadphase_collisionPairs_r; + bodyB.position.vsub(bodyA.position,r); + var boundingRadiusSum2 = Math.pow(bodyA.boundingRadius + bodyB.boundingRadius, 2); + var norm2 = r.norm2(); + if(norm2 < boundingRadiusSum2){ + pairs1.push(bodyA); + pairs2.push(bodyB); + } +}; + +/** + * Check if the bounding boxes of two bodies are intersecting. + * @method doBoundingBoxBroadphase + * @param {Body} bodyA + * @param {Body} bodyB + * @param {Array} pairs1 + * @param {Array} pairs2 + */ +Broadphase.prototype.doBoundingBoxBroadphase = function(bodyA,bodyB,pairs1,pairs2){ + if(bodyA.aabbNeedsUpdate){ + bodyA.computeAABB(); + } + if(bodyB.aabbNeedsUpdate){ + bodyB.computeAABB(); + } + + // Check AABB / AABB + if(bodyA.aabb.overlaps(bodyB.aabb)){ + pairs1.push(bodyA); + pairs2.push(bodyB); + } +}; + +/** + * Removes duplicate pairs from the pair arrays. + * @method makePairsUnique + * @param {Array} pairs1 + * @param {Array} pairs2 + */ +var Broadphase_makePairsUnique_temp = { keys:[] }, + Broadphase_makePairsUnique_p1 = [], + Broadphase_makePairsUnique_p2 = []; +Broadphase.prototype.makePairsUnique = function(pairs1,pairs2){ + var t = Broadphase_makePairsUnique_temp, + p1 = Broadphase_makePairsUnique_p1, + p2 = Broadphase_makePairsUnique_p2, + N = pairs1.length; + + for(var i=0; i!==N; i++){ + p1[i] = pairs1[i]; + p2[i] = pairs2[i]; + } + + pairs1.length = 0; + pairs2.length = 0; + + for(var i=0; i!==N; i++){ + var id1 = p1[i].id, + id2 = p2[i].id; + var key = id1 < id2 ? id1+","+id2 : id2+","+id1; + t[key] = i; + t.keys.push(key); + } + + for(var i=0; i!==t.keys.length; i++){ + var key = t.keys.pop(), + pairIndex = t[key]; + pairs1.push(p1[pairIndex]); + pairs2.push(p2[pairIndex]); + delete t[key]; + } +}; + +/** + * To be implemented by subcasses + * @method setWorld + * @param {World} world + */ +Broadphase.prototype.setWorld = function(world){ +}; + +/** + * Check if the bounding spheres of two bodies overlap. + * @method boundingSphereCheck + * @param {Body} bodyA + * @param {Body} bodyB + * @return {boolean} + */ +var bsc_dist = new Vec3(); +Broadphase.boundingSphereCheck = function(bodyA,bodyB){ + var dist = bsc_dist; + bodyA.position.vsub(bodyB.position,dist); + return Math.pow(bodyA.shape.boundingSphereRadius + bodyB.shape.boundingSphereRadius,2) > dist.norm2(); +}; + +/** + * Returns all the bodies within the AABB. + * @method aabbQuery + * @param {World} world + * @param {AABB} aabb + * @param {array} result An array to store resulting bodies in. + * @return {array} + */ +Broadphase.prototype.aabbQuery = function(world, aabb, result){ + console.warn('.aabbQuery is not implemented in this Broadphase subclass.'); + return []; +}; +},{"../math/Quaternion":29,"../math/Vec3":31,"../objects/Body":32,"../shapes/Plane":43,"../shapes/Shape":44}],6:[function(require,module,exports){ +module.exports = GridBroadphase; + +var Broadphase = require('./Broadphase'); +var Vec3 = require('../math/Vec3'); +var Shape = require('../shapes/Shape'); + +/** + * Axis aligned uniform grid broadphase. + * @class GridBroadphase + * @constructor + * @extends Broadphase + * @todo Needs support for more than just planes and spheres. + * @param {Vec3} aabbMin + * @param {Vec3} aabbMax + * @param {Number} nx Number of boxes along x + * @param {Number} ny Number of boxes along y + * @param {Number} nz Number of boxes along z + */ +function GridBroadphase(aabbMin,aabbMax,nx,ny,nz){ + Broadphase.apply(this); + this.nx = nx || 10; + this.ny = ny || 10; + this.nz = nz || 10; + this.aabbMin = aabbMin || new Vec3(100,100,100); + this.aabbMax = aabbMax || new Vec3(-100,-100,-100); + var nbins = this.nx * this.ny * this.nz; + if (nbins <= 0) { + throw "GridBroadphase: Each dimension's n must be >0"; + } + this.bins = []; + this.binLengths = []; //Rather than continually resizing arrays (thrashing the memory), just record length and allow them to grow + this.bins.length = nbins; + this.binLengths.length = nbins; + for (var i=0;i= nx) { xoff0 = nx - 1; } + if (yoff0 < 0) { yoff0 = 0; } else if (yoff0 >= ny) { yoff0 = ny - 1; } + if (zoff0 < 0) { zoff0 = 0; } else if (zoff0 >= nz) { zoff0 = nz - 1; } + if (xoff1 < 0) { xoff1 = 0; } else if (xoff1 >= nx) { xoff1 = nx - 1; } + if (yoff1 < 0) { yoff1 = 0; } else if (yoff1 >= ny) { yoff1 = ny - 1; } + if (zoff1 < 0) { zoff1 = 0; } else if (zoff1 >= nz) { zoff1 = nz - 1; } + + xoff0 *= xstep; + yoff0 *= ystep; + zoff0 *= zstep; + xoff1 *= xstep; + yoff1 *= ystep; + zoff1 *= zstep; + + for (var xoff = xoff0; xoff <= xoff1; xoff += xstep) { + for (var yoff = yoff0; yoff <= yoff1; yoff += ystep) { + for (var zoff = zoff0; zoff <= zoff1; zoff += zstep) { + var idx = xoff+yoff+zoff; + bins[idx][binLengths[idx]++] = bi; + } + } + } + } + + // Put all bodies into the bins + for(var i=0; i!==N; i++){ + var bi = bodies[i]; + var si = bi.shape; + + switch(si.type){ + case SPHERE: + // Put in bin + // check if overlap with other bins + var x = bi.position.x, + y = bi.position.y, + z = bi.position.z; + var r = si.radius; + + addBoxToBins(x-r, y-r, z-r, x+r, y+r, z+r, bi); + break; + + case PLANE: + if(si.worldNormalNeedsUpdate){ + si.computeWorldNormal(bi.quaternion); + } + var planeNormal = si.worldNormal; + + //Relative position from origin of plane object to the first bin + //Incremented as we iterate through the bins + var xreset = xmin + binsizeX*0.5 - bi.position.x, + yreset = ymin + binsizeY*0.5 - bi.position.y, + zreset = zmin + binsizeZ*0.5 - bi.position.z; + + var d = GridBroadphase_collisionPairs_d; + d.set(xreset, yreset, zreset); + + for (var xi = 0, xoff = 0; xi !== nx; xi++, xoff += xstep, d.y = yreset, d.x += binsizeX) { + for (var yi = 0, yoff = 0; yi !== ny; yi++, yoff += ystep, d.z = zreset, d.y += binsizeY) { + for (var zi = 0, zoff = 0; zi !== nz; zi++, zoff += zstep, d.z += binsizeZ) { + if (d.dot(planeNormal) < binRadius) { + var idx = xoff + yoff + zoff; + bins[idx][binLengths[idx]++] = bi; + } + } + } + } + break; + + default: + if (bi.aabbNeedsUpdate) { + bi.computeAABB(); + } + + addBoxToBins( + bi.aabb.lowerBound.x, + bi.aabb.lowerBound.y, + bi.aabb.lowerBound.z, + bi.aabb.upperBound.x, + bi.aabb.upperBound.y, + bi.aabb.upperBound.z, + bi); + break; + } + } + + // Check each bin + for(var i=0; i!==Nbins; i++){ + var binLength = binLengths[i]; + //Skip bins with no potential collisions + if (binLength > 1) { + var bin = bins[i]; + + // Do N^2 broadphase inside + for(var xi=0; xi!==binLength; xi++){ + var bi = bin[xi]; + for(var yi=0; yi!==xi; yi++){ + var bj = bin[yi]; + if(this.needBroadphaseCollision(bi,bj)){ + this.intersectionTest(bi,bj,pairs1,pairs2); + } + } + } + } + } + +// for (var zi = 0, zoff=0; zi < nz; zi++, zoff+= zstep) { +// console.log("layer "+zi); +// for (var yi = 0, yoff=0; yi < ny; yi++, yoff += ystep) { +// var row = ''; +// for (var xi = 0, xoff=0; xi < nx; xi++, xoff += xstep) { +// var idx = xoff + yoff + zoff; +// row += ' ' + binLengths[idx]; +// } +// console.log(row); +// } +// } + + this.makePairsUnique(pairs1,pairs2); +}; + +},{"../math/Vec3":31,"../shapes/Shape":44,"./Broadphase":5}],7:[function(require,module,exports){ +module.exports = NaiveBroadphase; + +var Broadphase = require('./Broadphase'); +var AABB = require('./AABB'); + +/** + * Naive broadphase implementation, used in lack of better ones. + * @class NaiveBroadphase + * @constructor + * @description The naive broadphase looks at all possible pairs without restriction, therefore it has complexity N^2 (which is bad) + * @extends Broadphase + */ +function NaiveBroadphase(){ + Broadphase.apply(this); +} +NaiveBroadphase.prototype = new Broadphase(); +NaiveBroadphase.prototype.constructor = NaiveBroadphase; + +/** + * Get all the collision pairs in the physics world + * @method collisionPairs + * @param {World} world + * @param {Array} pairs1 + * @param {Array} pairs2 + */ +NaiveBroadphase.prototype.collisionPairs = function(world,pairs1,pairs2){ + var bodies = world.bodies, + n = bodies.length, + i,j,bi,bj; + + // Naive N^2 ftw! + for(i=0; i!==n; i++){ + for(j=0; j!==i; j++){ + + bi = bodies[i]; + bj = bodies[j]; + + if(!this.needBroadphaseCollision(bi,bj)){ + continue; + } + + this.intersectionTest(bi,bj,pairs1,pairs2); + } + } +}; + +var tmpAABB = new AABB(); + +/** + * Returns all the bodies within an AABB. + * @method aabbQuery + * @param {World} world + * @param {AABB} aabb + * @param {array} result An array to store resulting bodies in. + * @return {array} + */ +NaiveBroadphase.prototype.aabbQuery = function(world, aabb, result){ + result = result || []; + + for(var i = 0; i < world.bodies.length; i++){ + var b = world.bodies[i]; + + if(b.aabbNeedsUpdate){ + b.computeAABB(); + } + + // Ugly hack until Body gets aabb + if(b.aabb.overlaps(aabb)){ + result.push(b); + } + } + + return result; +}; +},{"./AABB":3,"./Broadphase":5}],8:[function(require,module,exports){ +module.exports = ObjectCollisionMatrix; + +/** + * Records what objects are colliding with each other + * @class ObjectCollisionMatrix + * @constructor + */ +function ObjectCollisionMatrix() { + + /** + * The matrix storage + * @property matrix + * @type {Object} + */ + this.matrix = {}; +} + +/** + * @method get + * @param {Number} i + * @param {Number} j + * @return {Number} + */ +ObjectCollisionMatrix.prototype.get = function(i, j) { + i = i.id; + j = j.id; + if (j > i) { + var temp = j; + j = i; + i = temp; + } + return i+'-'+j in this.matrix; +}; + +/** + * @method set + * @param {Number} i + * @param {Number} j + * @param {Number} value + */ +ObjectCollisionMatrix.prototype.set = function(i, j, value) { + i = i.id; + j = j.id; + if (j > i) { + var temp = j; + j = i; + i = temp; + } + if (value) { + this.matrix[i+'-'+j] = true; + } + else { + delete this.matrix[i+'-'+j]; + } +}; + +/** + * Empty the matrix + * @method reset + */ +ObjectCollisionMatrix.prototype.reset = function() { + this.matrix = {}; +}; + +/** + * Set max number of objects + * @method setNumObjects + * @param {Number} n + */ +ObjectCollisionMatrix.prototype.setNumObjects = function(n) { +}; + +},{}],9:[function(require,module,exports){ +module.exports = OverlapKeeper; + +/** + * @class OverlapKeeper + * @constructor + */ +function OverlapKeeper() { + this.current = []; + this.previous = []; +} + +OverlapKeeper.prototype.getKey = function(i, j) { + if (j < i) { + var temp = j; + j = i; + i = temp; + } + return (i << 16) | j; +}; + + +/** + * @method set + * @param {Number} i + * @param {Number} j + */ +OverlapKeeper.prototype.set = function(i, j) { + // Insertion sort. This way the diff will have linear complexity. + var key = this.getKey(i, j); + var current = this.current; + var index = 0; + while(key > current[index]){ + index++; + } + if(key === current[index]){ + return; // Pair was already added + } + for(var j=current.length-1; j>=index; j--){ + current[j + 1] = current[j]; + } + current[index] = key; +}; + +/** + * @method tick + */ +OverlapKeeper.prototype.tick = function() { + var tmp = this.current; + this.current = this.previous; + this.previous = tmp; + this.current.length = 0; +}; + +function unpackAndPush(array, key){ + array.push((key & 0xFFFF0000) >> 16, key & 0x0000FFFF); +} + +/** + * @method getDiff + * @param {array} additions + * @param {array} removals + */ +OverlapKeeper.prototype.getDiff = function(additions, removals) { + var a = this.current; + var b = this.previous; + var al = a.length; + var bl = b.length; + + var j=0; + for (var i = 0; i < al; i++) { + var found = false; + var keyA = a[i]; + while(keyA > b[j]){ + j++; + } + found = keyA === b[j]; + + if(!found){ + unpackAndPush(additions, keyA); + } + } + j = 0; + for (var i = 0; i < bl; i++) { + var found = false; + var keyB = b[i]; + while(keyB > a[j]){ + j++; + } + found = a[j] === keyB; + + if(!found){ + unpackAndPush(removals, keyB); + } + } +}; +},{}],10:[function(require,module,exports){ +module.exports = Ray; + +var Vec3 = require('../math/Vec3'); +var Quaternion = require('../math/Quaternion'); +var Transform = require('../math/Transform'); +var ConvexPolyhedron = require('../shapes/ConvexPolyhedron'); +var Box = require('../shapes/Box'); +var RaycastResult = require('../collision/RaycastResult'); +var Shape = require('../shapes/Shape'); +var AABB = require('../collision/AABB'); + +/** + * A line in 3D space that intersects bodies and return points. + * @class Ray + * @constructor + * @param {Vec3} from + * @param {Vec3} to + */ +function Ray(from, to){ + /** + * @property {Vec3} from + */ + this.from = from ? from.clone() : new Vec3(); + + /** + * @property {Vec3} to + */ + this.to = to ? to.clone() : new Vec3(); + + /** + * @private + * @property {Vec3} _direction + */ + this._direction = new Vec3(); + + /** + * The precision of the ray. Used when checking parallelity etc. + * @property {Number} precision + */ + this.precision = 0.0001; + + /** + * Set to true if you want the Ray to take .collisionResponse flags into account on bodies and shapes. + * @property {Boolean} checkCollisionResponse + */ + this.checkCollisionResponse = true; + + /** + * If set to true, the ray skips any hits with normal.dot(rayDirection) < 0. + * @property {Boolean} skipBackfaces + */ + this.skipBackfaces = false; + + /** + * @property {number} collisionFilterMask + * @default -1 + */ + this.collisionFilterMask = -1; + + /** + * @property {number} collisionFilterGroup + * @default -1 + */ + this.collisionFilterGroup = -1; + + /** + * The intersection mode. Should be Ray.ANY, Ray.ALL or Ray.CLOSEST. + * @property {number} mode + */ + this.mode = Ray.ANY; + + /** + * Current result object. + * @property {RaycastResult} result + */ + this.result = new RaycastResult(); + + /** + * Will be set to true during intersectWorld() if the ray hit anything. + * @property {Boolean} hasHit + */ + this.hasHit = false; + + /** + * Current, user-provided result callback. Will be used if mode is Ray.ALL. + * @property {Function} callback + */ + this.callback = function(result){}; +} +Ray.prototype.constructor = Ray; + +Ray.CLOSEST = 1; +Ray.ANY = 2; +Ray.ALL = 4; + +var tmpAABB = new AABB(); +var tmpArray = []; + +/** + * Do itersection against all bodies in the given World. + * @method intersectWorld + * @param {World} world + * @param {object} options + * @return {Boolean} True if the ray hit anything, otherwise false. + */ +Ray.prototype.intersectWorld = function (world, options) { + this.mode = options.mode || Ray.ANY; + this.result = options.result || new RaycastResult(); + this.skipBackfaces = !!options.skipBackfaces; + this.collisionFilterMask = typeof(options.collisionFilterMask) !== 'undefined' ? options.collisionFilterMask : -1; + this.collisionFilterGroup = typeof(options.collisionFilterGroup) !== 'undefined' ? options.collisionFilterGroup : -1; + if(options.from){ + this.from.copy(options.from); + } + if(options.to){ + this.to.copy(options.to); + } + this.callback = options.callback || function(){}; + this.hasHit = false; + + this.result.reset(); + this._updateDirection(); + + this.getAABB(tmpAABB); + tmpArray.length = 0; + world.broadphase.aabbQuery(world, tmpAABB, tmpArray); + this.intersectBodies(tmpArray); + + return this.hasHit; +}; + +var v1 = new Vec3(), + v2 = new Vec3(); + +/* + * As per "Barycentric Technique" as named here http://www.blackpawn.com/texts/pointinpoly/default.html But without the division + */ +Ray.pointInTriangle = pointInTriangle; +function pointInTriangle(p, a, b, c) { + c.vsub(a,v0); + b.vsub(a,v1); + p.vsub(a,v2); + + var dot00 = v0.dot( v0 ); + var dot01 = v0.dot( v1 ); + var dot02 = v0.dot( v2 ); + var dot11 = v1.dot( v1 ); + var dot12 = v1.dot( v2 ); + + var u,v; + + return ( (u = dot11 * dot02 - dot01 * dot12) >= 0 ) && + ( (v = dot00 * dot12 - dot01 * dot02) >= 0 ) && + ( u + v < ( dot00 * dot11 - dot01 * dot01 ) ); +} + +/** + * Shoot a ray at a body, get back information about the hit. + * @method intersectBody + * @private + * @param {Body} body + * @param {RaycastResult} [result] Deprecated - set the result property of the Ray instead. + */ +var intersectBody_xi = new Vec3(); +var intersectBody_qi = new Quaternion(); +Ray.prototype.intersectBody = function (body, result) { + if(result){ + this.result = result; + this._updateDirection(); + } + var checkCollisionResponse = this.checkCollisionResponse; + + if(checkCollisionResponse && !body.collisionResponse){ + return; + } + + if((this.collisionFilterGroup & body.collisionFilterMask)===0 || (body.collisionFilterGroup & this.collisionFilterMask)===0){ + return; + } + + var xi = intersectBody_xi; + var qi = intersectBody_qi; + + for (var i = 0, N = body.shapes.length; i < N; i++) { + var shape = body.shapes[i]; + + if(checkCollisionResponse && !shape.collisionResponse){ + continue; // Skip + } + + body.quaternion.mult(body.shapeOrientations[i], qi); + body.quaternion.vmult(body.shapeOffsets[i], xi); + xi.vadd(body.position, xi); + + this.intersectShape( + shape, + qi, + xi, + body + ); + + if(this.result._shouldStop){ + break; + } + } +}; + +/** + * @method intersectBodies + * @param {Array} bodies An array of Body objects. + * @param {RaycastResult} [result] Deprecated + */ +Ray.prototype.intersectBodies = function (bodies, result) { + if(result){ + this.result = result; + this._updateDirection(); + } + + for ( var i = 0, l = bodies.length; !this.result._shouldStop && i < l; i ++ ) { + this.intersectBody(bodies[i]); + } +}; + +/** + * Updates the _direction vector. + * @private + * @method _updateDirection + */ +Ray.prototype._updateDirection = function(){ + this.to.vsub(this.from, this._direction); + this._direction.normalize(); +}; + +/** + * @method intersectShape + * @private + * @param {Shape} shape + * @param {Quaternion} quat + * @param {Vec3} position + * @param {Body} body + */ +Ray.prototype.intersectShape = function(shape, quat, position, body){ + var from = this.from; + + + // Checking boundingSphere + var distance = distanceFromIntersection(from, this._direction, position); + if ( distance > shape.boundingSphereRadius ) { + return; + } + + var intersectMethod = this[shape.type]; + if(intersectMethod){ + intersectMethod.call(this, shape, quat, position, body, shape); + } +}; + +var vector = new Vec3(); +var normal = new Vec3(); +var intersectPoint = new Vec3(); + +var a = new Vec3(); +var b = new Vec3(); +var c = new Vec3(); +var d = new Vec3(); + +var tmpRaycastResult = new RaycastResult(); + +/** + * @method intersectBox + * @private + * @param {Shape} shape + * @param {Quaternion} quat + * @param {Vec3} position + * @param {Body} body + */ +Ray.prototype.intersectBox = function(shape, quat, position, body, reportedShape){ + return this.intersectConvex(shape.convexPolyhedronRepresentation, quat, position, body, reportedShape); +}; +Ray.prototype[Shape.types.BOX] = Ray.prototype.intersectBox; + +/** + * @method intersectPlane + * @private + * @param {Shape} shape + * @param {Quaternion} quat + * @param {Vec3} position + * @param {Body} body + */ +Ray.prototype.intersectPlane = function(shape, quat, position, body, reportedShape){ + var from = this.from; + var to = this.to; + var direction = this._direction; + + // Get plane normal + var worldNormal = new Vec3(0, 0, 1); + quat.vmult(worldNormal, worldNormal); + + var len = new Vec3(); + from.vsub(position, len); + var planeToFrom = len.dot(worldNormal); + to.vsub(position, len); + var planeToTo = len.dot(worldNormal); + + if(planeToFrom * planeToTo > 0){ + // "from" and "to" are on the same side of the plane... bail out + return; + } + + if(from.distanceTo(to) < planeToFrom){ + return; + } + + var n_dot_dir = worldNormal.dot(direction); + + if (Math.abs(n_dot_dir) < this.precision) { + // No intersection + return; + } + + var planePointToFrom = new Vec3(); + var dir_scaled_with_t = new Vec3(); + var hitPointWorld = new Vec3(); + + from.vsub(position, planePointToFrom); + var t = -worldNormal.dot(planePointToFrom) / n_dot_dir; + direction.scale(t, dir_scaled_with_t); + from.vadd(dir_scaled_with_t, hitPointWorld); + + this.reportIntersection(worldNormal, hitPointWorld, reportedShape, body, -1); +}; +Ray.prototype[Shape.types.PLANE] = Ray.prototype.intersectPlane; + +/** + * Get the world AABB of the ray. + * @method getAABB + * @param {AABB} aabb + */ +Ray.prototype.getAABB = function(result){ + var to = this.to; + var from = this.from; + result.lowerBound.x = Math.min(to.x, from.x); + result.lowerBound.y = Math.min(to.y, from.y); + result.lowerBound.z = Math.min(to.z, from.z); + result.upperBound.x = Math.max(to.x, from.x); + result.upperBound.y = Math.max(to.y, from.y); + result.upperBound.z = Math.max(to.z, from.z); +}; + +var intersectConvexOptions = { + faceList: [0] +}; +var worldPillarOffset = new Vec3(); +var intersectHeightfield_localRay = new Ray(); +var intersectHeightfield_index = []; +var intersectHeightfield_minMax = []; + +/** + * @method intersectHeightfield + * @private + * @param {Shape} shape + * @param {Quaternion} quat + * @param {Vec3} position + * @param {Body} body + */ +Ray.prototype.intersectHeightfield = function(shape, quat, position, body, reportedShape){ + var data = shape.data, + w = shape.elementSize; + + // Convert the ray to local heightfield coordinates + var localRay = intersectHeightfield_localRay; //new Ray(this.from, this.to); + localRay.from.copy(this.from); + localRay.to.copy(this.to); + Transform.pointToLocalFrame(position, quat, localRay.from, localRay.from); + Transform.pointToLocalFrame(position, quat, localRay.to, localRay.to); + localRay._updateDirection(); + + // Get the index of the data points to test against + var index = intersectHeightfield_index; + var iMinX, iMinY, iMaxX, iMaxY; + + // Set to max + iMinX = iMinY = 0; + iMaxX = iMaxY = shape.data.length - 1; + + var aabb = new AABB(); + localRay.getAABB(aabb); + + shape.getIndexOfPosition(aabb.lowerBound.x, aabb.lowerBound.y, index, true); + iMinX = Math.max(iMinX, index[0]); + iMinY = Math.max(iMinY, index[1]); + shape.getIndexOfPosition(aabb.upperBound.x, aabb.upperBound.y, index, true); + iMaxX = Math.min(iMaxX, index[0] + 1); + iMaxY = Math.min(iMaxY, index[1] + 1); + + for(var i = iMinX; i < iMaxX; i++){ + for(var j = iMinY; j < iMaxY; j++){ + + if(this.result._shouldStop){ + return; + } + + shape.getAabbAtIndex(i, j, aabb); + if(!aabb.overlapsRay(localRay)){ + continue; + } + + // Lower triangle + shape.getConvexTrianglePillar(i, j, false); + Transform.pointToWorldFrame(position, quat, shape.pillarOffset, worldPillarOffset); + this.intersectConvex(shape.pillarConvex, quat, worldPillarOffset, body, reportedShape, intersectConvexOptions); + + if(this.result._shouldStop){ + return; + } + + // Upper triangle + shape.getConvexTrianglePillar(i, j, true); + Transform.pointToWorldFrame(position, quat, shape.pillarOffset, worldPillarOffset); + this.intersectConvex(shape.pillarConvex, quat, worldPillarOffset, body, reportedShape, intersectConvexOptions); + } + } +}; +Ray.prototype[Shape.types.HEIGHTFIELD] = Ray.prototype.intersectHeightfield; + +var Ray_intersectSphere_intersectionPoint = new Vec3(); +var Ray_intersectSphere_normal = new Vec3(); + +/** + * @method intersectSphere + * @private + * @param {Shape} shape + * @param {Quaternion} quat + * @param {Vec3} position + * @param {Body} body + */ +Ray.prototype.intersectSphere = function(shape, quat, position, body, reportedShape){ + var from = this.from, + to = this.to, + r = shape.radius; + + var a = Math.pow(to.x - from.x, 2) + Math.pow(to.y - from.y, 2) + Math.pow(to.z - from.z, 2); + var b = 2 * ((to.x - from.x) * (from.x - position.x) + (to.y - from.y) * (from.y - position.y) + (to.z - from.z) * (from.z - position.z)); + var c = Math.pow(from.x - position.x, 2) + Math.pow(from.y - position.y, 2) + Math.pow(from.z - position.z, 2) - Math.pow(r, 2); + + var delta = Math.pow(b, 2) - 4 * a * c; + + var intersectionPoint = Ray_intersectSphere_intersectionPoint; + var normal = Ray_intersectSphere_normal; + + if(delta < 0){ + // No intersection + return; + + } else if(delta === 0){ + // single intersection point + from.lerp(to, delta, intersectionPoint); + + intersectionPoint.vsub(position, normal); + normal.normalize(); + + this.reportIntersection(normal, intersectionPoint, reportedShape, body, -1); + + } else { + var d1 = (- b - Math.sqrt(delta)) / (2 * a); + var d2 = (- b + Math.sqrt(delta)) / (2 * a); + + if(d1 >= 0 && d1 <= 1){ + from.lerp(to, d1, intersectionPoint); + intersectionPoint.vsub(position, normal); + normal.normalize(); + this.reportIntersection(normal, intersectionPoint, reportedShape, body, -1); + } + + if(this.result._shouldStop){ + return; + } + + if(d2 >= 0 && d2 <= 1){ + from.lerp(to, d2, intersectionPoint); + intersectionPoint.vsub(position, normal); + normal.normalize(); + this.reportIntersection(normal, intersectionPoint, reportedShape, body, -1); + } + } +}; +Ray.prototype[Shape.types.SPHERE] = Ray.prototype.intersectSphere; + + +var intersectConvex_normal = new Vec3(); +var intersectConvex_minDistNormal = new Vec3(); +var intersectConvex_minDistIntersect = new Vec3(); +var intersectConvex_vector = new Vec3(); + +/** + * @method intersectConvex + * @private + * @param {Shape} shape + * @param {Quaternion} quat + * @param {Vec3} position + * @param {Body} body + * @param {object} [options] + * @param {array} [options.faceList] + */ +Ray.prototype.intersectConvex = function intersectConvex( + shape, + quat, + position, + body, + reportedShape, + options +){ + var minDistNormal = intersectConvex_minDistNormal; + var normal = intersectConvex_normal; + var vector = intersectConvex_vector; + var minDistIntersect = intersectConvex_minDistIntersect; + var faceList = (options && options.faceList) || null; + + // Checking faces + var faces = shape.faces, + vertices = shape.vertices, + normals = shape.faceNormals; + var direction = this._direction; + + var from = this.from; + var to = this.to; + var fromToDistance = from.distanceTo(to); + + var minDist = -1; + var Nfaces = faceList ? faceList.length : faces.length; + var result = this.result; + + for (var j = 0; !result._shouldStop && j < Nfaces; j++) { + var fi = faceList ? faceList[j] : j; + + var face = faces[fi]; + var faceNormal = normals[fi]; + var q = quat; + var x = position; + + // determine if ray intersects the plane of the face + // note: this works regardless of the direction of the face normal + + // Get plane point in world coordinates... + vector.copy(vertices[face[0]]); + q.vmult(vector,vector); + vector.vadd(x,vector); + + // ...but make it relative to the ray from. We'll fix this later. + vector.vsub(from,vector); + + // Get plane normal + q.vmult(faceNormal,normal); + + // If this dot product is negative, we have something interesting + var dot = direction.dot(normal); + + // Bail out if ray and plane are parallel + if ( Math.abs( dot ) < this.precision ){ + continue; + } + + // calc distance to plane + var scalar = normal.dot(vector) / dot; + + // if negative distance, then plane is behind ray + if (scalar < 0){ + continue; + } + + // if (dot < 0) { + + // Intersection point is from + direction * scalar + direction.mult(scalar,intersectPoint); + intersectPoint.vadd(from,intersectPoint); + + // a is the point we compare points b and c with. + a.copy(vertices[face[0]]); + q.vmult(a,a); + x.vadd(a,a); + + for(var i = 1; !result._shouldStop && i < face.length - 1; i++){ + // Transform 3 vertices to world coords + b.copy(vertices[face[i]]); + c.copy(vertices[face[i+1]]); + q.vmult(b,b); + q.vmult(c,c); + x.vadd(b,b); + x.vadd(c,c); + + var distance = intersectPoint.distanceTo(from); + + if(!(pointInTriangle(intersectPoint, a, b, c) || pointInTriangle(intersectPoint, b, a, c)) || distance > fromToDistance){ + continue; + } + + this.reportIntersection(normal, intersectPoint, reportedShape, body, fi); + } + // } + } +}; +Ray.prototype[Shape.types.CONVEXPOLYHEDRON] = Ray.prototype.intersectConvex; + +var intersectTrimesh_normal = new Vec3(); +var intersectTrimesh_localDirection = new Vec3(); +var intersectTrimesh_localFrom = new Vec3(); +var intersectTrimesh_localTo = new Vec3(); +var intersectTrimesh_worldNormal = new Vec3(); +var intersectTrimesh_worldIntersectPoint = new Vec3(); +var intersectTrimesh_localAABB = new AABB(); +var intersectTrimesh_triangles = []; +var intersectTrimesh_treeTransform = new Transform(); + +/** + * @method intersectTrimesh + * @private + * @param {Shape} shape + * @param {Quaternion} quat + * @param {Vec3} position + * @param {Body} body + * @param {object} [options] + * @todo Optimize by transforming the world to local space first. + * @todo Use Octree lookup + */ +Ray.prototype.intersectTrimesh = function intersectTrimesh( + mesh, + quat, + position, + body, + reportedShape, + options +){ + var normal = intersectTrimesh_normal; + var triangles = intersectTrimesh_triangles; + var treeTransform = intersectTrimesh_treeTransform; + var minDistNormal = intersectConvex_minDistNormal; + var vector = intersectConvex_vector; + var minDistIntersect = intersectConvex_minDistIntersect; + var localAABB = intersectTrimesh_localAABB; + var localDirection = intersectTrimesh_localDirection; + var localFrom = intersectTrimesh_localFrom; + var localTo = intersectTrimesh_localTo; + var worldIntersectPoint = intersectTrimesh_worldIntersectPoint; + var worldNormal = intersectTrimesh_worldNormal; + var faceList = (options && options.faceList) || null; + + // Checking faces + var indices = mesh.indices, + vertices = mesh.vertices, + normals = mesh.faceNormals; + + var from = this.from; + var to = this.to; + var direction = this._direction; + + var minDist = -1; + treeTransform.position.copy(position); + treeTransform.quaternion.copy(quat); + + // Transform ray to local space! + Transform.vectorToLocalFrame(position, quat, direction, localDirection); + Transform.pointToLocalFrame(position, quat, from, localFrom); + Transform.pointToLocalFrame(position, quat, to, localTo); + + localTo.x *= mesh.scale.x; + localTo.y *= mesh.scale.y; + localTo.z *= mesh.scale.z; + localFrom.x *= mesh.scale.x; + localFrom.y *= mesh.scale.y; + localFrom.z *= mesh.scale.z; + + localTo.vsub(localFrom, localDirection); + localDirection.normalize(); + + var fromToDistanceSquared = localFrom.distanceSquared(localTo); + + mesh.tree.rayQuery(this, treeTransform, triangles); + + for (var i = 0, N = triangles.length; !this.result._shouldStop && i !== N; i++) { + var trianglesIndex = triangles[i]; + + mesh.getNormal(trianglesIndex, normal); + + // determine if ray intersects the plane of the face + // note: this works regardless of the direction of the face normal + + // Get plane point in world coordinates... + mesh.getVertex(indices[trianglesIndex * 3], a); + + // ...but make it relative to the ray from. We'll fix this later. + a.vsub(localFrom,vector); + + // If this dot product is negative, we have something interesting + var dot = localDirection.dot(normal); + + // Bail out if ray and plane are parallel + // if (Math.abs( dot ) < this.precision){ + // continue; + // } + + // calc distance to plane + var scalar = normal.dot(vector) / dot; + + // if negative distance, then plane is behind ray + if (scalar < 0){ + continue; + } + + // Intersection point is from + direction * scalar + localDirection.scale(scalar,intersectPoint); + intersectPoint.vadd(localFrom,intersectPoint); + + // Get triangle vertices + mesh.getVertex(indices[trianglesIndex * 3 + 1], b); + mesh.getVertex(indices[trianglesIndex * 3 + 2], c); + + var squaredDistance = intersectPoint.distanceSquared(localFrom); + + if(!(pointInTriangle(intersectPoint, b, a, c) || pointInTriangle(intersectPoint, a, b, c)) || squaredDistance > fromToDistanceSquared){ + continue; + } + + // transform intersectpoint and normal to world + Transform.vectorToWorldFrame(quat, normal, worldNormal); + Transform.pointToWorldFrame(position, quat, intersectPoint, worldIntersectPoint); + this.reportIntersection(worldNormal, worldIntersectPoint, reportedShape, body, trianglesIndex); + } + triangles.length = 0; +}; +Ray.prototype[Shape.types.TRIMESH] = Ray.prototype.intersectTrimesh; + + +/** + * @method reportIntersection + * @private + * @param {Vec3} normal + * @param {Vec3} hitPointWorld + * @param {Shape} shape + * @param {Body} body + * @return {boolean} True if the intersections should continue + */ +Ray.prototype.reportIntersection = function(normal, hitPointWorld, shape, body, hitFaceIndex){ + var from = this.from; + var to = this.to; + var distance = from.distanceTo(hitPointWorld); + var result = this.result; + + // Skip back faces? + if(this.skipBackfaces && normal.dot(this._direction) > 0){ + return; + } + + result.hitFaceIndex = typeof(hitFaceIndex) !== 'undefined' ? hitFaceIndex : -1; + + switch(this.mode){ + case Ray.ALL: + this.hasHit = true; + result.set( + from, + to, + normal, + hitPointWorld, + shape, + body, + distance + ); + result.hasHit = true; + this.callback(result); + break; + + case Ray.CLOSEST: + + // Store if closer than current closest + if(distance < result.distance || !result.hasHit){ + this.hasHit = true; + result.hasHit = true; + result.set( + from, + to, + normal, + hitPointWorld, + shape, + body, + distance + ); + } + break; + + case Ray.ANY: + + // Report and stop. + this.hasHit = true; + result.hasHit = true; + result.set( + from, + to, + normal, + hitPointWorld, + shape, + body, + distance + ); + result._shouldStop = true; + break; + } +}; + +var v0 = new Vec3(), + intersect = new Vec3(); +function distanceFromIntersection(from, direction, position) { + + // v0 is vector from from to position + position.vsub(from,v0); + var dot = v0.dot(direction); + + // intersect = direction*dot + from + direction.mult(dot,intersect); + intersect.vadd(from,intersect); + + var distance = position.distanceTo(intersect); + + return distance; +} + + +},{"../collision/AABB":3,"../collision/RaycastResult":11,"../math/Quaternion":29,"../math/Transform":30,"../math/Vec3":31,"../shapes/Box":38,"../shapes/ConvexPolyhedron":39,"../shapes/Shape":44}],11:[function(require,module,exports){ +var Vec3 = require('../math/Vec3'); + +module.exports = RaycastResult; + +/** + * Storage for Ray casting data. + * @class RaycastResult + * @constructor + */ +function RaycastResult(){ + + /** + * @property {Vec3} rayFromWorld + */ + this.rayFromWorld = new Vec3(); + + /** + * @property {Vec3} rayToWorld + */ + this.rayToWorld = new Vec3(); + + /** + * @property {Vec3} hitNormalWorld + */ + this.hitNormalWorld = new Vec3(); + + /** + * @property {Vec3} hitPointWorld + */ + this.hitPointWorld = new Vec3(); + + /** + * @property {boolean} hasHit + */ + this.hasHit = false; + + /** + * The hit shape, or null. + * @property {Shape} shape + */ + this.shape = null; + + /** + * The hit body, or null. + * @property {Body} body + */ + this.body = null; + + /** + * The index of the hit triangle, if the hit shape was a trimesh. + * @property {number} hitFaceIndex + * @default -1 + */ + this.hitFaceIndex = -1; + + /** + * Distance to the hit. Will be set to -1 if there was no hit. + * @property {number} distance + * @default -1 + */ + this.distance = -1; + + /** + * If the ray should stop traversing the bodies. + * @private + * @property {Boolean} _shouldStop + * @default false + */ + this._shouldStop = false; +} + +/** + * Reset all result data. + * @method reset + */ +RaycastResult.prototype.reset = function () { + this.rayFromWorld.setZero(); + this.rayToWorld.setZero(); + this.hitNormalWorld.setZero(); + this.hitPointWorld.setZero(); + this.hasHit = false; + this.shape = null; + this.body = null; + this.hitFaceIndex = -1; + this.distance = -1; + this._shouldStop = false; +}; + +/** + * @method abort + */ +RaycastResult.prototype.abort = function(){ + this._shouldStop = true; +}; + +/** + * @method set + * @param {Vec3} rayFromWorld + * @param {Vec3} rayToWorld + * @param {Vec3} hitNormalWorld + * @param {Vec3} hitPointWorld + * @param {Shape} shape + * @param {Body} body + * @param {number} distance + */ +RaycastResult.prototype.set = function( + rayFromWorld, + rayToWorld, + hitNormalWorld, + hitPointWorld, + shape, + body, + distance +){ + this.rayFromWorld.copy(rayFromWorld); + this.rayToWorld.copy(rayToWorld); + this.hitNormalWorld.copy(hitNormalWorld); + this.hitPointWorld.copy(hitPointWorld); + this.shape = shape; + this.body = body; + this.distance = distance; +}; +},{"../math/Vec3":31}],12:[function(require,module,exports){ +var Shape = require('../shapes/Shape'); +var Broadphase = require('../collision/Broadphase'); + +module.exports = SAPBroadphase; + +/** + * Sweep and prune broadphase along one axis. + * + * @class SAPBroadphase + * @constructor + * @param {World} [world] + * @extends Broadphase + */ +function SAPBroadphase(world){ + Broadphase.apply(this); + + /** + * List of bodies currently in the broadphase. + * @property axisList + * @type {Array} + */ + this.axisList = []; + + /** + * The world to search in. + * @property world + * @type {World} + */ + this.world = null; + + /** + * Axis to sort the bodies along. Set to 0 for x axis, and 1 for y axis. For best performance, choose an axis that the bodies are spread out more on. + * @property axisIndex + * @type {Number} + */ + this.axisIndex = 0; + + var axisList = this.axisList; + + this._addBodyHandler = function(e){ + axisList.push(e.body); + }; + + this._removeBodyHandler = function(e){ + var idx = axisList.indexOf(e.body); + if(idx !== -1){ + axisList.splice(idx,1); + } + }; + + if(world){ + this.setWorld(world); + } +} +SAPBroadphase.prototype = new Broadphase(); + +/** + * Change the world + * @method setWorld + * @param {World} world + */ +SAPBroadphase.prototype.setWorld = function(world){ + // Clear the old axis array + this.axisList.length = 0; + + // Add all bodies from the new world + for(var i=0; i=0;j--) { + if(a[j].aabb.lowerBound.x <= v.aabb.lowerBound.x){ + break; + } + a[j+1] = a[j]; + } + a[j+1] = v; + } + return a; +}; + +/** + * @static + * @method insertionSortY + * @param {Array} a + * @return {Array} + */ +SAPBroadphase.insertionSortY = function(a) { + for(var i=1,l=a.length;i=0;j--) { + if(a[j].aabb.lowerBound.y <= v.aabb.lowerBound.y){ + break; + } + a[j+1] = a[j]; + } + a[j+1] = v; + } + return a; +}; + +/** + * @static + * @method insertionSortZ + * @param {Array} a + * @return {Array} + */ +SAPBroadphase.insertionSortZ = function(a) { + for(var i=1,l=a.length;i=0;j--) { + if(a[j].aabb.lowerBound.z <= v.aabb.lowerBound.z){ + break; + } + a[j+1] = a[j]; + } + a[j+1] = v; + } + return a; +}; + +/** + * Collect all collision pairs + * @method collisionPairs + * @param {World} world + * @param {Array} p1 + * @param {Array} p2 + */ +SAPBroadphase.prototype.collisionPairs = function(world,p1,p2){ + var bodies = this.axisList, + N = bodies.length, + axisIndex = this.axisIndex, + i, j; + + if(this.dirty){ + this.sortList(); + this.dirty = false; + } + + // Look through the list + for(i=0; i !== N; i++){ + var bi = bodies[i]; + + for(j=i+1; j < N; j++){ + var bj = bodies[j]; + + if(!this.needBroadphaseCollision(bi,bj)){ + continue; + } + + if(!SAPBroadphase.checkBounds(bi,bj,axisIndex)){ + break; + } + + this.intersectionTest(bi,bj,p1,p2); + } + } +}; + +SAPBroadphase.prototype.sortList = function(){ + var axisList = this.axisList; + var axisIndex = this.axisIndex; + var N = axisList.length; + + // Update AABBs + for(var i = 0; i!==N; i++){ + var bi = axisList[i]; + if(bi.aabbNeedsUpdate){ + bi.computeAABB(); + } + } + + // Sort the list + if(axisIndex === 0){ + SAPBroadphase.insertionSortX(axisList); + } else if(axisIndex === 1){ + SAPBroadphase.insertionSortY(axisList); + } else if(axisIndex === 2){ + SAPBroadphase.insertionSortZ(axisList); + } +}; + +/** + * Check if the bounds of two bodies overlap, along the given SAP axis. + * @static + * @method checkBounds + * @param {Body} bi + * @param {Body} bj + * @param {Number} axisIndex + * @return {Boolean} + */ +SAPBroadphase.checkBounds = function(bi, bj, axisIndex){ + var biPos; + var bjPos; + + if(axisIndex === 0){ + biPos = bi.position.x; + bjPos = bj.position.x; + } else if(axisIndex === 1){ + biPos = bi.position.y; + bjPos = bj.position.y; + } else if(axisIndex === 2){ + biPos = bi.position.z; + bjPos = bj.position.z; + } + + var ri = bi.boundingRadius, + rj = bj.boundingRadius, + boundA1 = biPos - ri, + boundA2 = biPos + ri, + boundB1 = bjPos - rj, + boundB2 = bjPos + rj; + + return boundB1 < boundA2; +}; + +/** + * Computes the variance of the body positions and estimates the best + * axis to use. Will automatically set property .axisIndex. + * @method autoDetectAxis + */ +SAPBroadphase.prototype.autoDetectAxis = function(){ + var sumX=0, + sumX2=0, + sumY=0, + sumY2=0, + sumZ=0, + sumZ2=0, + bodies = this.axisList, + N = bodies.length, + invN=1/N; + + for(var i=0; i!==N; i++){ + var b = bodies[i]; + + var centerX = b.position.x; + sumX += centerX; + sumX2 += centerX*centerX; + + var centerY = b.position.y; + sumY += centerY; + sumY2 += centerY*centerY; + + var centerZ = b.position.z; + sumZ += centerZ; + sumZ2 += centerZ*centerZ; + } + + var varianceX = sumX2 - sumX*sumX*invN, + varianceY = sumY2 - sumY*sumY*invN, + varianceZ = sumZ2 - sumZ*sumZ*invN; + + if(varianceX > varianceY){ + if(varianceX > varianceZ){ + this.axisIndex = 0; + } else{ + this.axisIndex = 2; + } + } else if(varianceY > varianceZ){ + this.axisIndex = 1; + } else{ + this.axisIndex = 2; + } +}; + +/** + * Returns all the bodies within an AABB. + * @method aabbQuery + * @param {World} world + * @param {AABB} aabb + * @param {array} result An array to store resulting bodies in. + * @return {array} + */ +SAPBroadphase.prototype.aabbQuery = function(world, aabb, result){ + result = result || []; + + if(this.dirty){ + this.sortList(); + this.dirty = false; + } + + var axisIndex = this.axisIndex, axis = 'x'; + if(axisIndex === 1){ axis = 'y'; } + if(axisIndex === 2){ axis = 'z'; } + + var axisList = this.axisList; + var lower = aabb.lowerBound[axis]; + var upper = aabb.upperBound[axis]; + for(var i = 0; i < axisList.length; i++){ + var b = axisList[i]; + + if(b.aabbNeedsUpdate){ + b.computeAABB(); + } + + if(b.aabb.overlaps(aabb)){ + result.push(b); + } + } + + return result; +}; +},{"../collision/Broadphase":5,"../shapes/Shape":44}],13:[function(require,module,exports){ +module.exports = ConeTwistConstraint; + +var Constraint = require('./Constraint'); +var PointToPointConstraint = require('./PointToPointConstraint'); +var ConeEquation = require('../equations/ConeEquation'); +var RotationalEquation = require('../equations/RotationalEquation'); +var ContactEquation = require('../equations/ContactEquation'); +var Vec3 = require('../math/Vec3'); + +/** + * @class ConeTwistConstraint + * @constructor + * @author schteppe + * @param {Body} bodyA + * @param {Body} bodyB + * @param {object} [options] + * @param {Vec3} [options.pivotA] + * @param {Vec3} [options.pivotB] + * @param {Vec3} [options.axisA] + * @param {Vec3} [options.axisB] + * @param {Number} [options.maxForce=1e6] + * @extends PointToPointConstraint + */ +function ConeTwistConstraint(bodyA, bodyB, options){ + options = options || {}; + var maxForce = typeof(options.maxForce) !== 'undefined' ? options.maxForce : 1e6; + + // Set pivot point in between + var pivotA = options.pivotA ? options.pivotA.clone() : new Vec3(); + var pivotB = options.pivotB ? options.pivotB.clone() : new Vec3(); + this.axisA = options.axisA ? options.axisA.clone() : new Vec3(); + this.axisB = options.axisB ? options.axisB.clone() : new Vec3(); + + PointToPointConstraint.call(this, bodyA, pivotA, bodyB, pivotB, maxForce); + + this.collideConnected = !!options.collideConnected; + + this.angle = typeof(options.angle) !== 'undefined' ? options.angle : 0; + + /** + * @property {ConeEquation} coneEquation + */ + var c = this.coneEquation = new ConeEquation(bodyA,bodyB,options); + + /** + * @property {RotationalEquation} twistEquation + */ + var t = this.twistEquation = new RotationalEquation(bodyA,bodyB,options); + this.twistAngle = typeof(options.twistAngle) !== 'undefined' ? options.twistAngle : 0; + + // Make the cone equation push the bodies toward the cone axis, not outward + c.maxForce = 0; + c.minForce = -maxForce; + + // Make the twist equation add torque toward the initial position + t.maxForce = 0; + t.minForce = -maxForce; + + this.equations.push(c, t); +} +ConeTwistConstraint.prototype = new PointToPointConstraint(); +ConeTwistConstraint.constructor = ConeTwistConstraint; + +var ConeTwistConstraint_update_tmpVec1 = new Vec3(); +var ConeTwistConstraint_update_tmpVec2 = new Vec3(); + +ConeTwistConstraint.prototype.update = function(){ + var bodyA = this.bodyA, + bodyB = this.bodyB, + cone = this.coneEquation, + twist = this.twistEquation; + + PointToPointConstraint.prototype.update.call(this); + + // Update the axes to the cone constraint + bodyA.vectorToWorldFrame(this.axisA, cone.axisA); + bodyB.vectorToWorldFrame(this.axisB, cone.axisB); + + // Update the world axes in the twist constraint + this.axisA.tangents(twist.axisA, twist.axisA); + bodyA.vectorToWorldFrame(twist.axisA, twist.axisA); + + this.axisB.tangents(twist.axisB, twist.axisB); + bodyB.vectorToWorldFrame(twist.axisB, twist.axisB); + + cone.angle = this.angle; + twist.maxAngle = this.twistAngle; +}; + + +},{"../equations/ConeEquation":19,"../equations/ContactEquation":20,"../equations/RotationalEquation":23,"../math/Vec3":31,"./Constraint":14,"./PointToPointConstraint":18}],14:[function(require,module,exports){ +module.exports = Constraint; + +var Utils = require('../utils/Utils'); + +/** + * Constraint base class + * @class Constraint + * @author schteppe + * @constructor + * @param {Body} bodyA + * @param {Body} bodyB + * @param {object} [options] + * @param {boolean} [options.collideConnected=true] + * @param {boolean} [options.wakeUpBodies=true] + */ +function Constraint(bodyA, bodyB, options){ + options = Utils.defaults(options,{ + collideConnected : true, + wakeUpBodies : true, + }); + + /** + * Equations to be solved in this constraint + * @property equations + * @type {Array} + */ + this.equations = []; + + /** + * @property {Body} bodyA + */ + this.bodyA = bodyA; + + /** + * @property {Body} bodyB + */ + this.bodyB = bodyB; + + /** + * @property {Number} id + */ + this.id = Constraint.idCounter++; + + /** + * Set to true if you want the bodies to collide when they are connected. + * @property collideConnected + * @type {boolean} + */ + this.collideConnected = options.collideConnected; + + if(options.wakeUpBodies){ + if(bodyA){ + bodyA.wakeUp(); + } + if(bodyB){ + bodyB.wakeUp(); + } + } +} + +/** + * Update all the equations with data. + * @method update + */ +Constraint.prototype.update = function(){ + throw new Error("method update() not implmemented in this Constraint subclass!"); +}; + +/** + * Enables all equations in the constraint. + * @method enable + */ +Constraint.prototype.enable = function(){ + var eqs = this.equations; + for(var i=0; i + // G = [0 axisA 0 -axisB] + + GA.rotational.copy(axisA); + axisB.negate(GB.rotational); + + var GW = this.computeGW() - this.targetVelocity, + GiMf = this.computeGiMf(); + + var B = - GW * b - h * GiMf; + + return B; +}; + +},{"../math/Mat3":28,"../math/Vec3":31,"./Equation":21}],25:[function(require,module,exports){ +var Utils = require('../utils/Utils'); + +module.exports = ContactMaterial; + +/** + * Defines what happens when two materials meet. + * @class ContactMaterial + * @constructor + * @param {Material} m1 + * @param {Material} m2 + * @param {object} [options] + * @param {Number} [options.friction=0.3] + * @param {Number} [options.restitution=0.3] + * @param {number} [options.contactEquationStiffness=1e7] + * @param {number} [options.contactEquationRelaxation=3] + * @param {number} [options.frictionEquationStiffness=1e7] + * @param {Number} [options.frictionEquationRelaxation=3] + */ +function ContactMaterial(m1, m2, options){ + options = Utils.defaults(options, { + friction: 0.3, + restitution: 0.3, + contactEquationStiffness: 1e7, + contactEquationRelaxation: 3, + frictionEquationStiffness: 1e7, + frictionEquationRelaxation: 3 + }); + + /** + * Identifier of this material + * @property {Number} id + */ + this.id = ContactMaterial.idCounter++; + + /** + * Participating materials + * @property {Array} materials + * @todo Should be .materialA and .materialB instead + */ + this.materials = [m1, m2]; + + /** + * Friction coefficient + * @property {Number} friction + */ + this.friction = options.friction; + + /** + * Restitution coefficient + * @property {Number} restitution + */ + this.restitution = options.restitution; + + /** + * Stiffness of the produced contact equations + * @property {Number} contactEquationStiffness + */ + this.contactEquationStiffness = options.contactEquationStiffness; + + /** + * Relaxation time of the produced contact equations + * @property {Number} contactEquationRelaxation + */ + this.contactEquationRelaxation = options.contactEquationRelaxation; + + /** + * Stiffness of the produced friction equations + * @property {Number} frictionEquationStiffness + */ + this.frictionEquationStiffness = options.frictionEquationStiffness; + + /** + * Relaxation time of the produced friction equations + * @property {Number} frictionEquationRelaxation + */ + this.frictionEquationRelaxation = options.frictionEquationRelaxation; +} + +ContactMaterial.idCounter = 0; + +},{"../utils/Utils":54}],26:[function(require,module,exports){ +module.exports = Material; + +/** + * Defines a physics material. + * @class Material + * @constructor + * @param {object} [options] + * @author schteppe + */ +function Material(options){ + var name = ''; + options = options || {}; + + // Backwards compatibility fix + if(typeof(options) === 'string'){ + name = options; + options = {}; + } else if(typeof(options) === 'object') { + name = ''; + } + + /** + * @property name + * @type {String} + */ + this.name = name; + + /** + * material id. + * @property id + * @type {number} + */ + this.id = Material.idCounter++; + + /** + * Friction for this material. If non-negative, it will be used instead of the friction given by ContactMaterials. If there's no matching ContactMaterial, the value from .defaultContactMaterial in the World will be used. + * @property {number} friction + */ + this.friction = typeof(options.friction) !== 'undefined' ? options.friction : -1; + + /** + * Restitution for this material. If non-negative, it will be used instead of the restitution given by ContactMaterials. If there's no matching ContactMaterial, the value from .defaultContactMaterial in the World will be used. + * @property {number} restitution + */ + this.restitution = typeof(options.restitution) !== 'undefined' ? options.restitution : -1; +} + +Material.idCounter = 0; + +},{}],27:[function(require,module,exports){ +module.exports = JacobianElement; + +var Vec3 = require('./Vec3'); + +/** + * An element containing 6 entries, 3 spatial and 3 rotational degrees of freedom. + * @class JacobianElement + * @constructor + */ +function JacobianElement(){ + + /** + * @property {Vec3} spatial + */ + this.spatial = new Vec3(); + + /** + * @property {Vec3} rotational + */ + this.rotational = new Vec3(); +} + +/** + * Multiply with other JacobianElement + * @method multiplyElement + * @param {JacobianElement} element + * @return {Number} + */ +JacobianElement.prototype.multiplyElement = function(element){ + return element.spatial.dot(this.spatial) + element.rotational.dot(this.rotational); +}; + +/** + * Multiply with two vectors + * @method multiplyVectors + * @param {Vec3} spatial + * @param {Vec3} rotational + * @return {Number} + */ +JacobianElement.prototype.multiplyVectors = function(spatial,rotational){ + return spatial.dot(this.spatial) + rotational.dot(this.rotational); +}; + +},{"./Vec3":31}],28:[function(require,module,exports){ +module.exports = Mat3; + +var Vec3 = require('./Vec3'); + +/** + * A 3x3 matrix. + * @class Mat3 + * @constructor + * @param array elements Array of nine elements. Optional. + * @author schteppe / http://github.com/schteppe + */ +function Mat3(elements){ + /** + * A vector of length 9, containing all matrix elements + * @property {Array} elements + */ + if(elements){ + this.elements = elements; + } else { + this.elements = [0,0,0,0,0,0,0,0,0]; + } +} + +/** + * Sets the matrix to identity + * @method identity + * @todo Should perhaps be renamed to setIdentity() to be more clear. + * @todo Create another function that immediately creates an identity matrix eg. eye() + */ +Mat3.prototype.identity = function(){ + var e = this.elements; + e[0] = 1; + e[1] = 0; + e[2] = 0; + + e[3] = 0; + e[4] = 1; + e[5] = 0; + + e[6] = 0; + e[7] = 0; + e[8] = 1; +}; + +/** + * Set all elements to zero + * @method setZero + */ +Mat3.prototype.setZero = function(){ + var e = this.elements; + e[0] = 0; + e[1] = 0; + e[2] = 0; + e[3] = 0; + e[4] = 0; + e[5] = 0; + e[6] = 0; + e[7] = 0; + e[8] = 0; +}; + +/** + * Sets the matrix diagonal elements from a Vec3 + * @method setTrace + * @param {Vec3} vec3 + */ +Mat3.prototype.setTrace = function(vec3){ + var e = this.elements; + e[0] = vec3.x; + e[4] = vec3.y; + e[8] = vec3.z; +}; + +/** + * Gets the matrix diagonal elements + * @method getTrace + * @return {Vec3} + */ +Mat3.prototype.getTrace = function(target){ + var target = target || new Vec3(); + var e = this.elements; + target.x = e[0]; + target.y = e[4]; + target.z = e[8]; +}; + +/** + * Matrix-Vector multiplication + * @method vmult + * @param {Vec3} v The vector to multiply with + * @param {Vec3} target Optional, target to save the result in. + */ +Mat3.prototype.vmult = function(v,target){ + target = target || new Vec3(); + + var e = this.elements, + x = v.x, + y = v.y, + z = v.z; + target.x = e[0]*x + e[1]*y + e[2]*z; + target.y = e[3]*x + e[4]*y + e[5]*z; + target.z = e[6]*x + e[7]*y + e[8]*z; + + return target; +}; + +/** + * Matrix-scalar multiplication + * @method smult + * @param {Number} s + */ +Mat3.prototype.smult = function(s){ + for(var i=0; i1 acos and sqrt will produce errors, this cant happen if quaternion is normalised + var angle = 2 * Math.acos(this.w); + var s = Math.sqrt(1-this.w*this.w); // assuming quaternion normalised then w is less than 1, so term always positive. + if (s < 0.001) { // test to avoid divide by zero, s is always positive due to sqrt + // if s close to zero then direction of axis not important + targetAxis.x = this.x; // if it is important that axis is normalised then replace with x=1; y=z=0; + targetAxis.y = this.y; + targetAxis.z = this.z; + } else { + targetAxis.x = this.x / s; // normalise axis + targetAxis.y = this.y / s; + targetAxis.z = this.z / s; + } + return [targetAxis,angle]; +}; + +var sfv_t1 = new Vec3(), + sfv_t2 = new Vec3(); + +/** + * Set the quaternion value given two vectors. The resulting rotation will be the needed rotation to rotate u to v. + * @method setFromVectors + * @param {Vec3} u + * @param {Vec3} v + */ +Quaternion.prototype.setFromVectors = function(u,v){ + if(u.isAntiparallelTo(v)){ + var t1 = sfv_t1; + var t2 = sfv_t2; + + u.tangents(t1,t2); + this.setFromAxisAngle(t1,Math.PI); + } else { + var a = u.cross(v); + this.x = a.x; + this.y = a.y; + this.z = a.z; + this.w = Math.sqrt(Math.pow(u.norm(),2) * Math.pow(v.norm(),2)) + u.dot(v); + this.normalize(); + } + return this; +}; + +/** + * Quaternion multiplication + * @method mult + * @param {Quaternion} q + * @param {Quaternion} target Optional. + * @return {Quaternion} + */ +var Quaternion_mult_va = new Vec3(); +var Quaternion_mult_vb = new Vec3(); +var Quaternion_mult_vaxvb = new Vec3(); +Quaternion.prototype.mult = function(q,target){ + target = target || new Quaternion(); + + var ax = this.x, ay = this.y, az = this.z, aw = this.w, + bx = q.x, by = q.y, bz = q.z, bw = q.w; + + target.x = ax * bw + aw * bx + ay * bz - az * by; + target.y = ay * bw + aw * by + az * bx - ax * bz; + target.z = az * bw + aw * bz + ax * by - ay * bx; + target.w = aw * bw - ax * bx - ay * by - az * bz; + + return target; +}; + +/** + * Get the inverse quaternion rotation. + * @method inverse + * @param {Quaternion} target + * @return {Quaternion} + */ +Quaternion.prototype.inverse = function(target){ + var x = this.x, y = this.y, z = this.z, w = this.w; + target = target || new Quaternion(); + + this.conjugate(target); + var inorm2 = 1/(x*x + y*y + z*z + w*w); + target.x *= inorm2; + target.y *= inorm2; + target.z *= inorm2; + target.w *= inorm2; + + return target; +}; + +/** + * Get the quaternion conjugate + * @method conjugate + * @param {Quaternion} target + * @return {Quaternion} + */ +Quaternion.prototype.conjugate = function(target){ + target = target || new Quaternion(); + + target.x = -this.x; + target.y = -this.y; + target.z = -this.z; + target.w = this.w; + + return target; +}; + +/** + * Normalize the quaternion. Note that this changes the values of the quaternion. + * @method normalize + */ +Quaternion.prototype.normalize = function(){ + var l = Math.sqrt(this.x*this.x+this.y*this.y+this.z*this.z+this.w*this.w); + if ( l === 0 ) { + this.x = 0; + this.y = 0; + this.z = 0; + this.w = 0; + } else { + l = 1 / l; + this.x *= l; + this.y *= l; + this.z *= l; + this.w *= l; + } + return this; +}; + +/** + * Approximation of quaternion normalization. Works best when quat is already almost-normalized. + * @method normalizeFast + * @see http://jsperf.com/fast-quaternion-normalization + * @author unphased, https://github.com/unphased + */ +Quaternion.prototype.normalizeFast = function () { + var f = (3.0-(this.x*this.x+this.y*this.y+this.z*this.z+this.w*this.w))/2.0; + if ( f === 0 ) { + this.x = 0; + this.y = 0; + this.z = 0; + this.w = 0; + } else { + this.x *= f; + this.y *= f; + this.z *= f; + this.w *= f; + } + return this; +}; + +/** + * Multiply the quaternion by a vector + * @method vmult + * @param {Vec3} v + * @param {Vec3} target Optional + * @return {Vec3} + */ +Quaternion.prototype.vmult = function(v,target){ + target = target || new Vec3(); + + var x = v.x, + y = v.y, + z = v.z; + + var qx = this.x, + qy = this.y, + qz = this.z, + qw = this.w; + + // q*v + var ix = qw * x + qy * z - qz * y, + iy = qw * y + qz * x - qx * z, + iz = qw * z + qx * y - qy * x, + iw = -qx * x - qy * y - qz * z; + + target.x = ix * qw + iw * -qx + iy * -qz - iz * -qy; + target.y = iy * qw + iw * -qy + iz * -qx - ix * -qz; + target.z = iz * qw + iw * -qz + ix * -qy - iy * -qx; + + return target; +}; + +/** + * Copies value of source to this quaternion. + * @method copy + * @param {Quaternion} source + * @return {Quaternion} this + */ +Quaternion.prototype.copy = function(source){ + this.x = source.x; + this.y = source.y; + this.z = source.z; + this.w = source.w; + return this; +}; + +/** + * Convert the quaternion to euler angle representation. Order: YZX, as this page describes: http://www.euclideanspace.com/maths/standards/index.htm + * @method toEuler + * @param {Vec3} target + * @param string order Three-character string e.g. "YZX", which also is default. + */ +Quaternion.prototype.toEuler = function(target,order){ + order = order || "YZX"; + + var heading, attitude, bank; + var x = this.x, y = this.y, z = this.z, w = this.w; + + switch(order){ + case "YZX": + var test = x*y + z*w; + if (test > 0.499) { // singularity at north pole + heading = 2 * Math.atan2(x,w); + attitude = Math.PI/2; + bank = 0; + } + if (test < -0.499) { // singularity at south pole + heading = -2 * Math.atan2(x,w); + attitude = - Math.PI/2; + bank = 0; + } + if(isNaN(heading)){ + var sqx = x*x; + var sqy = y*y; + var sqz = z*z; + heading = Math.atan2(2*y*w - 2*x*z , 1 - 2*sqy - 2*sqz); // Heading + attitude = Math.asin(2*test); // attitude + bank = Math.atan2(2*x*w - 2*y*z , 1 - 2*sqx - 2*sqz); // bank + } + break; + default: + throw new Error("Euler order "+order+" not supported yet."); + } + + target.y = heading; + target.z = attitude; + target.x = bank; +}; + +/** + * See http://www.mathworks.com/matlabcentral/fileexchange/20696-function-to-convert-between-dcm-euler-angles-quaternions-and-euler-vectors/content/SpinCalc.m + * @method setFromEuler + * @param {Number} x + * @param {Number} y + * @param {Number} z + * @param {String} order The order to apply angles: 'XYZ' or 'YXZ' or any other combination + */ +Quaternion.prototype.setFromEuler = function ( x, y, z, order ) { + order = order || "XYZ"; + + var c1 = Math.cos( x / 2 ); + var c2 = Math.cos( y / 2 ); + var c3 = Math.cos( z / 2 ); + var s1 = Math.sin( x / 2 ); + var s2 = Math.sin( y / 2 ); + var s3 = Math.sin( z / 2 ); + + if ( order === 'XYZ' ) { + + this.x = s1 * c2 * c3 + c1 * s2 * s3; + this.y = c1 * s2 * c3 - s1 * c2 * s3; + this.z = c1 * c2 * s3 + s1 * s2 * c3; + this.w = c1 * c2 * c3 - s1 * s2 * s3; + + } else if ( order === 'YXZ' ) { + + this.x = s1 * c2 * c3 + c1 * s2 * s3; + this.y = c1 * s2 * c3 - s1 * c2 * s3; + this.z = c1 * c2 * s3 - s1 * s2 * c3; + this.w = c1 * c2 * c3 + s1 * s2 * s3; + + } else if ( order === 'ZXY' ) { + + this.x = s1 * c2 * c3 - c1 * s2 * s3; + this.y = c1 * s2 * c3 + s1 * c2 * s3; + this.z = c1 * c2 * s3 + s1 * s2 * c3; + this.w = c1 * c2 * c3 - s1 * s2 * s3; + + } else if ( order === 'ZYX' ) { + + this.x = s1 * c2 * c3 - c1 * s2 * s3; + this.y = c1 * s2 * c3 + s1 * c2 * s3; + this.z = c1 * c2 * s3 - s1 * s2 * c3; + this.w = c1 * c2 * c3 + s1 * s2 * s3; + + } else if ( order === 'YZX' ) { + + this.x = s1 * c2 * c3 + c1 * s2 * s3; + this.y = c1 * s2 * c3 + s1 * c2 * s3; + this.z = c1 * c2 * s3 - s1 * s2 * c3; + this.w = c1 * c2 * c3 - s1 * s2 * s3; + + } else if ( order === 'XZY' ) { + + this.x = s1 * c2 * c3 - c1 * s2 * s3; + this.y = c1 * s2 * c3 - s1 * c2 * s3; + this.z = c1 * c2 * s3 + s1 * s2 * c3; + this.w = c1 * c2 * c3 + s1 * s2 * s3; + + } + + return this; +}; + +/** + * @method clone + * @return {Quaternion} + */ +Quaternion.prototype.clone = function(){ + return new Quaternion(this.x, this.y, this.z, this.w); +}; + +/** + * Performs a spherical linear interpolation between two quat + * + * @method slerp + * @param {Quaternion} toQuat second operand + * @param {Number} t interpolation amount between the self quaternion and toQuat + * @param {Quaternion} [target] A quaternion to store the result in. If not provided, a new one will be created. + * @returns {Quaternion} The "target" object + */ +Quaternion.prototype.slerp = function (toQuat, t, target) { + target = target || new Quaternion(); + + var ax = this.x, + ay = this.y, + az = this.z, + aw = this.w, + bx = toQuat.x, + by = toQuat.y, + bz = toQuat.z, + bw = toQuat.w; + + var omega, cosom, sinom, scale0, scale1; + + // calc cosine + cosom = ax * bx + ay * by + az * bz + aw * bw; + + // adjust signs (if necessary) + if ( cosom < 0.0 ) { + cosom = -cosom; + bx = - bx; + by = - by; + bz = - bz; + bw = - bw; + } + + // calculate coefficients + if ( (1.0 - cosom) > 0.000001 ) { + // standard case (slerp) + omega = Math.acos(cosom); + sinom = Math.sin(omega); + scale0 = Math.sin((1.0 - t) * omega) / sinom; + scale1 = Math.sin(t * omega) / sinom; + } else { + // "from" and "to" quaternions are very close + // ... so we can do a linear interpolation + scale0 = 1.0 - t; + scale1 = t; + } + + // calculate final values + target.x = scale0 * ax + scale1 * bx; + target.y = scale0 * ay + scale1 * by; + target.z = scale0 * az + scale1 * bz; + target.w = scale0 * aw + scale1 * bw; + + return target; +}; + +/** + * Rotate an absolute orientation quaternion given an angular velocity and a time step. + * @param {Vec3} angularVelocity + * @param {number} dt + * @param {Vec3} angularFactor + * @param {Quaternion} target + * @return {Quaternion} The "target" object + */ +Quaternion.prototype.integrate = function(angularVelocity, dt, angularFactor, target){ + target = target || new Quaternion(); + + var ax = angularVelocity.x * angularFactor.x, + ay = angularVelocity.y * angularFactor.y, + az = angularVelocity.z * angularFactor.z, + bx = this.x, + by = this.y, + bz = this.z, + bw = this.w; + + var half_dt = dt * 0.5; + + target.x += half_dt * (ax * bw + ay * bz - az * by); + target.y += half_dt * (ay * bw + az * bx - ax * bz); + target.z += half_dt * (az * bw + ax * by - ay * bx); + target.w += half_dt * (- ax * bx - ay * by - az * bz); + + return target; +}; +},{"./Vec3":31}],30:[function(require,module,exports){ +var Vec3 = require('./Vec3'); +var Quaternion = require('./Quaternion'); + +module.exports = Transform; + +/** + * @class Transform + * @constructor + */ +function Transform(options) { + options = options || {}; + + /** + * @property {Vec3} position + */ + this.position = new Vec3(); + if(options.position){ + this.position.copy(options.position); + } + + /** + * @property {Quaternion} quaternion + */ + this.quaternion = new Quaternion(); + if(options.quaternion){ + this.quaternion.copy(options.quaternion); + } +} + +var tmpQuat = new Quaternion(); + +/** + * @static + * @method pointToLocaFrame + * @param {Vec3} position + * @param {Quaternion} quaternion + * @param {Vec3} worldPoint + * @param {Vec3} result + */ +Transform.pointToLocalFrame = function(position, quaternion, worldPoint, result){ + var result = result || new Vec3(); + worldPoint.vsub(position, result); + quaternion.conjugate(tmpQuat); + tmpQuat.vmult(result, result); + return result; +}; + +/** + * Get a global point in local transform coordinates. + * @method pointToLocal + * @param {Vec3} point + * @param {Vec3} result + * @return {Vec3} The "result" vector object + */ +Transform.prototype.pointToLocal = function(worldPoint, result){ + return Transform.pointToLocalFrame(this.position, this.quaternion, worldPoint, result); +}; + +/** + * @static + * @method pointToWorldFrame + * @param {Vec3} position + * @param {Vec3} quaternion + * @param {Vec3} localPoint + * @param {Vec3} result + */ +Transform.pointToWorldFrame = function(position, quaternion, localPoint, result){ + var result = result || new Vec3(); + quaternion.vmult(localPoint, result); + result.vadd(position, result); + return result; +}; + +/** + * Get a local point in global transform coordinates. + * @method pointToWorld + * @param {Vec3} point + * @param {Vec3} result + * @return {Vec3} The "result" vector object + */ +Transform.prototype.pointToWorld = function(localPoint, result){ + return Transform.pointToWorldFrame(this.position, this.quaternion, localPoint, result); +}; + + +Transform.prototype.vectorToWorldFrame = function(localVector, result){ + var result = result || new Vec3(); + this.quaternion.vmult(localVector, result); + return result; +}; + +Transform.vectorToWorldFrame = function(quaternion, localVector, result){ + quaternion.vmult(localVector, result); + return result; +}; + +Transform.vectorToLocalFrame = function(position, quaternion, worldVector, result){ + var result = result || new Vec3(); + quaternion.w *= -1; + quaternion.vmult(worldVector, result); + quaternion.w *= -1; + return result; +}; + +},{"./Quaternion":29,"./Vec3":31}],31:[function(require,module,exports){ +module.exports = Vec3; + +var Mat3 = require('./Mat3'); + +/** + * 3-dimensional vector + * @class Vec3 + * @constructor + * @param {Number} x + * @param {Number} y + * @param {Number} z + * @author schteppe + * @example + * var v = new Vec3(1, 2, 3); + * console.log('x=' + v.x); // x=1 + */ +function Vec3(x,y,z){ + /** + * @property x + * @type {Number} + */ + this.x = x||0.0; + + /** + * @property y + * @type {Number} + */ + this.y = y||0.0; + + /** + * @property z + * @type {Number} + */ + this.z = z||0.0; +} + +/** + * @static + * @property {Vec3} ZERO + */ +Vec3.ZERO = new Vec3(0, 0, 0); + +/** + * @static + * @property {Vec3} UNIT_X + */ +Vec3.UNIT_X = new Vec3(1, 0, 0); + +/** + * @static + * @property {Vec3} UNIT_Y + */ +Vec3.UNIT_Y = new Vec3(0, 1, 0); + +/** + * @static + * @property {Vec3} UNIT_Z + */ +Vec3.UNIT_Z = new Vec3(0, 0, 1); + +/** + * Vector cross product + * @method cross + * @param {Vec3} v + * @param {Vec3} target Optional. Target to save in. + * @return {Vec3} + */ +Vec3.prototype.cross = function(v,target){ + var vx=v.x, vy=v.y, vz=v.z, x=this.x, y=this.y, z=this.z; + target = target || new Vec3(); + + target.x = (y * vz) - (z * vy); + target.y = (z * vx) - (x * vz); + target.z = (x * vy) - (y * vx); + + return target; +}; + +/** + * Set the vectors' 3 elements + * @method set + * @param {Number} x + * @param {Number} y + * @param {Number} z + * @return Vec3 + */ +Vec3.prototype.set = function(x,y,z){ + this.x = x; + this.y = y; + this.z = z; + return this; +}; + +/** + * Set all components of the vector to zero. + * @method setZero + */ +Vec3.prototype.setZero = function(){ + this.x = this.y = this.z = 0; +}; + +/** + * Vector addition + * @method vadd + * @param {Vec3} v + * @param {Vec3} target Optional. + * @return {Vec3} + */ +Vec3.prototype.vadd = function(v,target){ + if(target){ + target.x = v.x + this.x; + target.y = v.y + this.y; + target.z = v.z + this.z; + } else { + return new Vec3(this.x + v.x, + this.y + v.y, + this.z + v.z); + } +}; + +/** + * Vector subtraction + * @method vsub + * @param {Vec3} v + * @param {Vec3} target Optional. Target to save in. + * @return {Vec3} + */ +Vec3.prototype.vsub = function(v,target){ + if(target){ + target.x = this.x - v.x; + target.y = this.y - v.y; + target.z = this.z - v.z; + } else { + return new Vec3(this.x-v.x, + this.y-v.y, + this.z-v.z); + } +}; + +/** + * Get the cross product matrix a_cross from a vector, such that a x b = a_cross * b = c + * @method crossmat + * @see http://www8.cs.umu.se/kurser/TDBD24/VT06/lectures/Lecture6.pdf + * @return {Mat3} + */ +Vec3.prototype.crossmat = function(){ + return new Mat3([ 0, -this.z, this.y, + this.z, 0, -this.x, + -this.y, this.x, 0]); +}; + +/** + * Normalize the vector. Note that this changes the values in the vector. + * @method normalize + * @return {Number} Returns the norm of the vector + */ +Vec3.prototype.normalize = function(){ + var x=this.x, y=this.y, z=this.z; + var n = Math.sqrt(x*x + y*y + z*z); + if(n>0.0){ + var invN = 1/n; + this.x *= invN; + this.y *= invN; + this.z *= invN; + } else { + // Make something up + this.x = 0; + this.y = 0; + this.z = 0; + } + return n; +}; + +/** + * Get the version of this vector that is of length 1. + * @method unit + * @param {Vec3} target Optional target to save in + * @return {Vec3} Returns the unit vector + */ +Vec3.prototype.unit = function(target){ + target = target || new Vec3(); + var x=this.x, y=this.y, z=this.z; + var ninv = Math.sqrt(x*x + y*y + z*z); + if(ninv>0.0){ + ninv = 1.0/ninv; + target.x = x * ninv; + target.y = y * ninv; + target.z = z * ninv; + } else { + target.x = 1; + target.y = 0; + target.z = 0; + } + return target; +}; + +/** + * Get the length of the vector + * @method norm + * @return {Number} + * @deprecated Use .length() instead + */ +Vec3.prototype.norm = function(){ + var x=this.x, y=this.y, z=this.z; + return Math.sqrt(x*x + y*y + z*z); +}; + +/** + * Get the length of the vector + * @method length + * @return {Number} + */ +Vec3.prototype.length = Vec3.prototype.norm; + +/** + * Get the squared length of the vector + * @method norm2 + * @return {Number} + * @deprecated Use .lengthSquared() instead. + */ +Vec3.prototype.norm2 = function(){ + return this.dot(this); +}; + +/** + * Get the squared length of the vector. + * @method lengthSquared + * @return {Number} + */ +Vec3.prototype.lengthSquared = Vec3.prototype.norm2; + +/** + * Get distance from this point to another point + * @method distanceTo + * @param {Vec3} p + * @return {Number} + */ +Vec3.prototype.distanceTo = function(p){ + var x=this.x, y=this.y, z=this.z; + var px=p.x, py=p.y, pz=p.z; + return Math.sqrt((px-x)*(px-x)+ + (py-y)*(py-y)+ + (pz-z)*(pz-z)); +}; + +/** + * Get squared distance from this point to another point + * @method distanceSquared + * @param {Vec3} p + * @return {Number} + */ +Vec3.prototype.distanceSquared = function(p){ + var x=this.x, y=this.y, z=this.z; + var px=p.x, py=p.y, pz=p.z; + return (px-x)*(px-x) + (py-y)*(py-y) + (pz-z)*(pz-z); +}; + +/** + * Multiply all the components of the vector with a scalar. + * @deprecated Use .scale instead + * @method mult + * @param {Number} scalar + * @param {Vec3} target The vector to save the result in. + * @return {Vec3} + * @deprecated Use .scale() instead + */ +Vec3.prototype.mult = function(scalar,target){ + target = target || new Vec3(); + var x = this.x, + y = this.y, + z = this.z; + target.x = scalar * x; + target.y = scalar * y; + target.z = scalar * z; + return target; +}; + +/** + * Multiply the vector with an other vector, component-wise. + * @method mult + * @param {Number} vector + * @param {Vec3} target The vector to save the result in. + * @return {Vec3} + */ +Vec3.prototype.vmul = function(vector, target){ + target = target || new Vec3(); + target.x = vector.x * this.x; + target.y = vector.y * this.y; + target.z = vector.z * this.z; + return target; +}; + +/** + * Multiply the vector with a scalar. + * @method scale + * @param {Number} scalar + * @param {Vec3} target + * @return {Vec3} + */ +Vec3.prototype.scale = Vec3.prototype.mult; + +/** + * Scale a vector and add it to this vector. Save the result in "target". (target = this + vector * scalar) + * @method addScaledVector + * @param {Number} scalar + * @param {Vec3} vector + * @param {Vec3} target The vector to save the result in. + * @return {Vec3} + */ +Vec3.prototype.addScaledVector = function(scalar, vector, target){ + target = target || new Vec3(); + target.x = this.x + scalar * vector.x; + target.y = this.y + scalar * vector.y; + target.z = this.z + scalar * vector.z; + return target; +}; + +/** + * Calculate dot product + * @method dot + * @param {Vec3} v + * @return {Number} + */ +Vec3.prototype.dot = function(v){ + return this.x * v.x + this.y * v.y + this.z * v.z; +}; + +/** + * @method isZero + * @return bool + */ +Vec3.prototype.isZero = function(){ + return this.x===0 && this.y===0 && this.z===0; +}; + +/** + * Make the vector point in the opposite direction. + * @method negate + * @param {Vec3} target Optional target to save in + * @return {Vec3} + */ +Vec3.prototype.negate = function(target){ + target = target || new Vec3(); + target.x = -this.x; + target.y = -this.y; + target.z = -this.z; + return target; +}; + +/** + * Compute two artificial tangents to the vector + * @method tangents + * @param {Vec3} t1 Vector object to save the first tangent in + * @param {Vec3} t2 Vector object to save the second tangent in + */ +var Vec3_tangents_n = new Vec3(); +var Vec3_tangents_randVec = new Vec3(); +Vec3.prototype.tangents = function(t1,t2){ + var norm = this.norm(); + if(norm>0.0){ + var n = Vec3_tangents_n; + var inorm = 1/norm; + n.set(this.x*inorm,this.y*inorm,this.z*inorm); + var randVec = Vec3_tangents_randVec; + if(Math.abs(n.x) < 0.9){ + randVec.set(1,0,0); + n.cross(randVec,t1); + } else { + randVec.set(0,1,0); + n.cross(randVec,t1); + } + n.cross(t1,t2); + } else { + // The normal length is zero, make something up + t1.set(1, 0, 0); + t2.set(0, 1, 0); + } +}; + +/** + * Converts to a more readable format + * @method toString + * @return string + */ +Vec3.prototype.toString = function(){ + return this.x+","+this.y+","+this.z; +}; + +/** + * Converts to an array + * @method toArray + * @return Array + */ +Vec3.prototype.toArray = function(){ + return [this.x, this.y, this.z]; +}; + +/** + * Copies value of source to this vector. + * @method copy + * @param {Vec3} source + * @return {Vec3} this + */ +Vec3.prototype.copy = function(source){ + this.x = source.x; + this.y = source.y; + this.z = source.z; + return this; +}; + + +/** + * Do a linear interpolation between two vectors + * @method lerp + * @param {Vec3} v + * @param {Number} t A number between 0 and 1. 0 will make this function return u, and 1 will make it return v. Numbers in between will generate a vector in between them. + * @param {Vec3} target + */ +Vec3.prototype.lerp = function(v,t,target){ + var x=this.x, y=this.y, z=this.z; + target.x = x + (v.x-x)*t; + target.y = y + (v.y-y)*t; + target.z = z + (v.z-z)*t; +}; + +/** + * Check if a vector equals is almost equal to another one. + * @method almostEquals + * @param {Vec3} v + * @param {Number} precision + * @return bool + */ +Vec3.prototype.almostEquals = function(v,precision){ + if(precision===undefined){ + precision = 1e-6; + } + if( Math.abs(this.x-v.x)>precision || + Math.abs(this.y-v.y)>precision || + Math.abs(this.z-v.z)>precision){ + return false; + } + return true; +}; + +/** + * Check if a vector is almost zero + * @method almostZero + * @param {Number} precision + */ +Vec3.prototype.almostZero = function(precision){ + if(precision===undefined){ + precision = 1e-6; + } + if( Math.abs(this.x)>precision || + Math.abs(this.y)>precision || + Math.abs(this.z)>precision){ + return false; + } + return true; +}; + +var antip_neg = new Vec3(); + +/** + * Check if the vector is anti-parallel to another vector. + * @method isAntiparallelTo + * @param {Vec3} v + * @param {Number} precision Set to zero for exact comparisons + * @return {Boolean} + */ +Vec3.prototype.isAntiparallelTo = function(v,precision){ + this.negate(antip_neg); + return antip_neg.almostEquals(v,precision); +}; + +/** + * Clone the vector + * @method clone + * @return {Vec3} + */ +Vec3.prototype.clone = function(){ + return new Vec3(this.x, this.y, this.z); +}; +},{"./Mat3":28}],32:[function(require,module,exports){ +module.exports = Body; + +var EventTarget = require('../utils/EventTarget'); +var Shape = require('../shapes/Shape'); +var Vec3 = require('../math/Vec3'); +var Mat3 = require('../math/Mat3'); +var Quaternion = require('../math/Quaternion'); +var Material = require('../material/Material'); +var AABB = require('../collision/AABB'); +var Box = require('../shapes/Box'); + +/** + * Base class for all body types. + * @class Body + * @constructor + * @extends EventTarget + * @param {object} [options] + * @param {Vec3} [options.position] + * @param {Vec3} [options.velocity] + * @param {Vec3} [options.angularVelocity] + * @param {Quaternion} [options.quaternion] + * @param {number} [options.mass] + * @param {Material} [options.material] + * @param {number} [options.type] + * @param {number} [options.linearDamping=0.01] + * @param {number} [options.angularDamping=0.01] + * @param {boolean} [options.allowSleep=true] + * @param {number} [options.sleepSpeedLimit=0.1] + * @param {number} [options.sleepTimeLimit=1] + * @param {number} [options.collisionFilterGroup=1] + * @param {number} [options.collisionFilterMask=-1] + * @param {boolean} [options.fixedRotation=false] + * @param {Vec3} [options.linearFactor] + * @param {Vec3} [options.angularFactor] + * @param {Shape} [options.shape] + * @example + * var body = new Body({ + * mass: 1 + * }); + * var shape = new Sphere(1); + * body.addShape(shape); + * world.addBody(body); + */ +function Body(options){ + options = options || {}; + + EventTarget.apply(this); + + this.id = Body.idCounter++; + + /** + * Reference to the world the body is living in + * @property world + * @type {World} + */ + this.world = null; + + /** + * Callback function that is used BEFORE stepping the system. Use it to apply forces, for example. Inside the function, "this" will refer to this Body object. + * @property preStep + * @type {Function} + * @deprecated Use World events instead + */ + this.preStep = null; + + /** + * Callback function that is used AFTER stepping the system. Inside the function, "this" will refer to this Body object. + * @property postStep + * @type {Function} + * @deprecated Use World events instead + */ + this.postStep = null; + + this.vlambda = new Vec3(); + + /** + * @property {Number} collisionFilterGroup + */ + this.collisionFilterGroup = typeof(options.collisionFilterGroup) === 'number' ? options.collisionFilterGroup : 1; + + /** + * @property {Number} collisionFilterMask + */ + this.collisionFilterMask = typeof(options.collisionFilterMask) === 'number' ? options.collisionFilterMask : -1; + + /** + * Whether to produce contact forces when in contact with other bodies. Note that contacts will be generated, but they will be disabled. + * @property {Number} collisionResponse + */ + this.collisionResponse = true; + + /** + * World space position of the body. + * @property position + * @type {Vec3} + */ + this.position = new Vec3(); + + /** + * @property {Vec3} previousPosition + */ + this.previousPosition = new Vec3(); + + /** + * Interpolated position of the body. + * @property {Vec3} interpolatedPosition + */ + this.interpolatedPosition = new Vec3(); + + /** + * Initial position of the body + * @property initPosition + * @type {Vec3} + */ + this.initPosition = new Vec3(); + + if(options.position){ + this.position.copy(options.position); + this.previousPosition.copy(options.position); + this.interpolatedPosition.copy(options.position); + this.initPosition.copy(options.position); + } + + /** + * World space velocity of the body. + * @property velocity + * @type {Vec3} + */ + this.velocity = new Vec3(); + + if(options.velocity){ + this.velocity.copy(options.velocity); + } + + /** + * @property initVelocity + * @type {Vec3} + */ + this.initVelocity = new Vec3(); + + /** + * Linear force on the body in world space. + * @property force + * @type {Vec3} + */ + this.force = new Vec3(); + + var mass = typeof(options.mass) === 'number' ? options.mass : 0; + + /** + * @property mass + * @type {Number} + * @default 0 + */ + this.mass = mass; + + /** + * @property invMass + * @type {Number} + */ + this.invMass = mass > 0 ? 1.0 / mass : 0; + + /** + * @property material + * @type {Material} + */ + this.material = options.material || null; + + /** + * @property linearDamping + * @type {Number} + */ + this.linearDamping = typeof(options.linearDamping) === 'number' ? options.linearDamping : 0.01; + + /** + * One of: Body.DYNAMIC, Body.STATIC and Body.KINEMATIC. + * @property type + * @type {Number} + */ + this.type = (mass <= 0.0 ? Body.STATIC : Body.DYNAMIC); + if(typeof(options.type) === typeof(Body.STATIC)){ + this.type = options.type; + } + + /** + * If true, the body will automatically fall to sleep. + * @property allowSleep + * @type {Boolean} + * @default true + */ + this.allowSleep = typeof(options.allowSleep) !== 'undefined' ? options.allowSleep : true; + + /** + * Current sleep state. + * @property sleepState + * @type {Number} + */ + this.sleepState = 0; + + /** + * If the speed (the norm of the velocity) is smaller than this value, the body is considered sleepy. + * @property sleepSpeedLimit + * @type {Number} + * @default 0.1 + */ + this.sleepSpeedLimit = typeof(options.sleepSpeedLimit) !== 'undefined' ? options.sleepSpeedLimit : 0.1; + + /** + * If the body has been sleepy for this sleepTimeLimit seconds, it is considered sleeping. + * @property sleepTimeLimit + * @type {Number} + * @default 1 + */ + this.sleepTimeLimit = typeof(options.sleepTimeLimit) !== 'undefined' ? options.sleepTimeLimit : 1; + + this.timeLastSleepy = 0; + + this._wakeUpAfterNarrowphase = false; + + /** + * World space rotational force on the body, around center of mass. + * @property {Vec3} torque + */ + this.torque = new Vec3(); + + /** + * World space orientation of the body. + * @property quaternion + * @type {Quaternion} + */ + this.quaternion = new Quaternion(); + + /** + * @property initQuaternion + * @type {Quaternion} + */ + this.initQuaternion = new Quaternion(); + + /** + * @property {Quaternion} previousQuaternion + */ + this.previousQuaternion = new Quaternion(); + + /** + * Interpolated orientation of the body. + * @property {Quaternion} interpolatedQuaternion + */ + this.interpolatedQuaternion = new Quaternion(); + + if(options.quaternion){ + this.quaternion.copy(options.quaternion); + this.initQuaternion.copy(options.quaternion); + this.previousQuaternion.copy(options.quaternion); + this.interpolatedQuaternion.copy(options.quaternion); + } + + /** + * Angular velocity of the body, in world space. Think of the angular velocity as a vector, which the body rotates around. The length of this vector determines how fast (in radians per second) the body rotates. + * @property angularVelocity + * @type {Vec3} + */ + this.angularVelocity = new Vec3(); + + if(options.angularVelocity){ + this.angularVelocity.copy(options.angularVelocity); + } + + /** + * @property initAngularVelocity + * @type {Vec3} + */ + this.initAngularVelocity = new Vec3(); + + /** + * @property shapes + * @type {array} + */ + this.shapes = []; + + /** + * Position of each Shape in the body, given in local Body space. + * @property shapeOffsets + * @type {array} + */ + this.shapeOffsets = []; + + /** + * Orientation of each Shape, given in local Body space. + * @property shapeOrientations + * @type {array} + */ + this.shapeOrientations = []; + + /** + * @property inertia + * @type {Vec3} + */ + this.inertia = new Vec3(); + + /** + * @property {Vec3} invInertia + */ + this.invInertia = new Vec3(); + + /** + * @property {Mat3} invInertiaWorld + */ + this.invInertiaWorld = new Mat3(); + + this.invMassSolve = 0; + + /** + * @property {Vec3} invInertiaSolve + */ + this.invInertiaSolve = new Vec3(); + + /** + * @property {Mat3} invInertiaWorldSolve + */ + this.invInertiaWorldSolve = new Mat3(); + + /** + * Set to true if you don't want the body to rotate. Make sure to run .updateMassProperties() after changing this. + * @property {Boolean} fixedRotation + * @default false + */ + this.fixedRotation = typeof(options.fixedRotation) !== "undefined" ? options.fixedRotation : false; + + /** + * @property {Number} angularDamping + */ + this.angularDamping = typeof(options.angularDamping) !== 'undefined' ? options.angularDamping : 0.01; + + /** + * Use this property to limit the motion along any world axis. (1,1,1) will allow motion along all axes while (0,0,0) allows none. + * @property {Vec3} linearFactor + */ + this.linearFactor = new Vec3(1,1,1); + if(options.linearFactor){ + this.linearFactor.copy(options.linearFactor); + } + + /** + * Use this property to limit the rotational motion along any world axis. (1,1,1) will allow rotation along all axes while (0,0,0) allows none. + * @property {Vec3} angularFactor + */ + this.angularFactor = new Vec3(1,1,1); + if(options.angularFactor){ + this.angularFactor.copy(options.angularFactor); + } + + /** + * World space bounding box of the body and its shapes. + * @property aabb + * @type {AABB} + */ + this.aabb = new AABB(); + + /** + * Indicates if the AABB needs to be updated before use. + * @property aabbNeedsUpdate + * @type {Boolean} + */ + this.aabbNeedsUpdate = true; + + /** + * Total bounding radius of the Body including its shapes, relative to body.position. + * @property boundingRadius + * @type {Number} + */ + this.boundingRadius = 0; + + this.wlambda = new Vec3(); + + if(options.shape){ + this.addShape(options.shape); + } + + this.updateMassProperties(); +} +Body.prototype = new EventTarget(); +Body.prototype.constructor = Body; + +/** + * Dispatched after two bodies collide. This event is dispatched on each + * of the two bodies involved in the collision. + * @event collide + * @param {Body} body The body that was involved in the collision. + * @param {ContactEquation} contact The details of the collision. + */ +Body.COLLIDE_EVENT_NAME = "collide"; + +/** + * A dynamic body is fully simulated. Can be moved manually by the user, but normally they move according to forces. A dynamic body can collide with all body types. A dynamic body always has finite, non-zero mass. + * @static + * @property DYNAMIC + * @type {Number} + */ +Body.DYNAMIC = 1; + +/** + * A static body does not move during simulation and behaves as if it has infinite mass. Static bodies can be moved manually by setting the position of the body. The velocity of a static body is always zero. Static bodies do not collide with other static or kinematic bodies. + * @static + * @property STATIC + * @type {Number} + */ +Body.STATIC = 2; + +/** + * A kinematic body moves under simulation according to its velocity. They do not respond to forces. They can be moved manually, but normally a kinematic body is moved by setting its velocity. A kinematic body behaves as if it has infinite mass. Kinematic bodies do not collide with other static or kinematic bodies. + * @static + * @property KINEMATIC + * @type {Number} + */ +Body.KINEMATIC = 4; + + + +/** + * @static + * @property AWAKE + * @type {number} + */ +Body.AWAKE = 0; + +/** + * @static + * @property SLEEPY + * @type {number} + */ +Body.SLEEPY = 1; + +/** + * @static + * @property SLEEPING + * @type {number} + */ +Body.SLEEPING = 2; + +Body.idCounter = 0; + +/** + * Dispatched after a sleeping body has woken up. + * @event wakeup + */ +Body.wakeupEvent = { + type: "wakeup" +}; + +/** + * Wake the body up. + * @method wakeUp + */ +Body.prototype.wakeUp = function(){ + var s = this.sleepState; + this.sleepState = 0; + this._wakeUpAfterNarrowphase = false; + if(s === Body.SLEEPING){ + this.dispatchEvent(Body.wakeupEvent); + } +}; + +/** + * Force body sleep + * @method sleep + */ +Body.prototype.sleep = function(){ + this.sleepState = Body.SLEEPING; + this.velocity.set(0,0,0); + this.angularVelocity.set(0,0,0); + this._wakeUpAfterNarrowphase = false; +}; + +/** + * Dispatched after a body has gone in to the sleepy state. + * @event sleepy + */ +Body.sleepyEvent = { + type: "sleepy" +}; + +/** + * Dispatched after a body has fallen asleep. + * @event sleep + */ +Body.sleepEvent = { + type: "sleep" +}; + +/** + * Called every timestep to update internal sleep timer and change sleep state if needed. + * @method sleepTick + * @param {Number} time The world time in seconds + */ +Body.prototype.sleepTick = function(time){ + if(this.allowSleep){ + var sleepState = this.sleepState; + var speedSquared = this.velocity.norm2() + this.angularVelocity.norm2(); + var speedLimitSquared = Math.pow(this.sleepSpeedLimit,2); + if(sleepState===Body.AWAKE && speedSquared < speedLimitSquared){ + this.sleepState = Body.SLEEPY; // Sleepy + this.timeLastSleepy = time; + this.dispatchEvent(Body.sleepyEvent); + } else if(sleepState===Body.SLEEPY && speedSquared > speedLimitSquared){ + this.wakeUp(); // Wake up + } else if(sleepState===Body.SLEEPY && (time - this.timeLastSleepy ) > this.sleepTimeLimit){ + this.sleep(); // Sleeping + this.dispatchEvent(Body.sleepEvent); + } + } +}; + +/** + * If the body is sleeping, it should be immovable / have infinite mass during solve. We solve it by having a separate "solve mass". + * @method updateSolveMassProperties + */ +Body.prototype.updateSolveMassProperties = function(){ + if(this.sleepState === Body.SLEEPING || this.type === Body.KINEMATIC){ + this.invMassSolve = 0; + this.invInertiaSolve.setZero(); + this.invInertiaWorldSolve.setZero(); + } else { + this.invMassSolve = this.invMass; + this.invInertiaSolve.copy(this.invInertia); + this.invInertiaWorldSolve.copy(this.invInertiaWorld); + } +}; + +/** + * Convert a world point to local body frame. + * @method pointToLocalFrame + * @param {Vec3} worldPoint + * @param {Vec3} result + * @return {Vec3} + */ +Body.prototype.pointToLocalFrame = function(worldPoint,result){ + var result = result || new Vec3(); + worldPoint.vsub(this.position,result); + this.quaternion.conjugate().vmult(result,result); + return result; +}; + +/** + * Convert a world vector to local body frame. + * @method vectorToLocalFrame + * @param {Vec3} worldPoint + * @param {Vec3} result + * @return {Vec3} + */ +Body.prototype.vectorToLocalFrame = function(worldVector, result){ + var result = result || new Vec3(); + this.quaternion.conjugate().vmult(worldVector,result); + return result; +}; + +/** + * Convert a local body point to world frame. + * @method pointToWorldFrame + * @param {Vec3} localPoint + * @param {Vec3} result + * @return {Vec3} + */ +Body.prototype.pointToWorldFrame = function(localPoint,result){ + var result = result || new Vec3(); + this.quaternion.vmult(localPoint,result); + result.vadd(this.position,result); + return result; +}; + +/** + * Convert a local body point to world frame. + * @method vectorToWorldFrame + * @param {Vec3} localVector + * @param {Vec3} result + * @return {Vec3} + */ +Body.prototype.vectorToWorldFrame = function(localVector, result){ + var result = result || new Vec3(); + this.quaternion.vmult(localVector, result); + return result; +}; + +var tmpVec = new Vec3(); +var tmpQuat = new Quaternion(); + +/** + * Add a shape to the body with a local offset and orientation. + * @method addShape + * @param {Shape} shape + * @param {Vec3} [_offset] + * @param {Quaternion} [_orientation] + * @return {Body} The body object, for chainability. + */ +Body.prototype.addShape = function(shape, _offset, _orientation){ + var offset = new Vec3(); + var orientation = new Quaternion(); + + if(_offset){ + offset.copy(_offset); + } + if(_orientation){ + orientation.copy(_orientation); + } + + this.shapes.push(shape); + this.shapeOffsets.push(offset); + this.shapeOrientations.push(orientation); + this.updateMassProperties(); + this.updateBoundingRadius(); + + this.aabbNeedsUpdate = true; + + shape.body = this; + + return this; +}; + +/** + * Update the bounding radius of the body. Should be done if any of the shapes are changed. + * @method updateBoundingRadius + */ +Body.prototype.updateBoundingRadius = function(){ + var shapes = this.shapes, + shapeOffsets = this.shapeOffsets, + N = shapes.length, + radius = 0; + + for(var i=0; i!==N; i++){ + var shape = shapes[i]; + shape.updateBoundingSphereRadius(); + var offset = shapeOffsets[i].norm(), + r = shape.boundingSphereRadius; + if(offset + r > radius){ + radius = offset + r; + } + } + + this.boundingRadius = radius; +}; + +var computeAABB_shapeAABB = new AABB(); + +/** + * Updates the .aabb + * @method computeAABB + * @todo rename to updateAABB() + */ +Body.prototype.computeAABB = function(){ + var shapes = this.shapes, + shapeOffsets = this.shapeOffsets, + shapeOrientations = this.shapeOrientations, + N = shapes.length, + offset = tmpVec, + orientation = tmpQuat, + bodyQuat = this.quaternion, + aabb = this.aabb, + shapeAABB = computeAABB_shapeAABB; + + for(var i=0; i!==N; i++){ + var shape = shapes[i]; + + // Get shape world position + bodyQuat.vmult(shapeOffsets[i], offset); + offset.vadd(this.position, offset); + + // Get shape world quaternion + shapeOrientations[i].mult(bodyQuat, orientation); + + // Get shape AABB + shape.calculateWorldAABB(offset, orientation, shapeAABB.lowerBound, shapeAABB.upperBound); + + if(i === 0){ + aabb.copy(shapeAABB); + } else { + aabb.extend(shapeAABB); + } + } + + this.aabbNeedsUpdate = false; +}; + +var uiw_m1 = new Mat3(), + uiw_m2 = new Mat3(), + uiw_m3 = new Mat3(); + +/** + * Update .inertiaWorld and .invInertiaWorld + * @method updateInertiaWorld + */ +Body.prototype.updateInertiaWorld = function(force){ + var I = this.invInertia; + if (I.x === I.y && I.y === I.z && !force) { + // If inertia M = s*I, where I is identity and s a scalar, then + // R*M*R' = R*(s*I)*R' = s*R*I*R' = s*R*R' = s*I = M + // where R is the rotation matrix. + // In other words, we don't have to transform the inertia if all + // inertia diagonal entries are equal. + } else { + var m1 = uiw_m1, + m2 = uiw_m2, + m3 = uiw_m3; + m1.setRotationFromQuaternion(this.quaternion); + m1.transpose(m2); + m1.scale(I,m1); + m1.mmult(m2,this.invInertiaWorld); + } +}; + +/** + * Apply force to a world point. This could for example be a point on the Body surface. Applying force this way will add to Body.force and Body.torque. + * @method applyForce + * @param {Vec3} force The amount of force to add. + * @param {Vec3} relativePoint A point relative to the center of mass to apply the force on. + */ +var Body_applyForce_r = new Vec3(); +var Body_applyForce_rotForce = new Vec3(); +Body.prototype.applyForce = function(force,relativePoint){ + if(this.type !== Body.DYNAMIC){ // Needed? + return; + } + + // Compute produced rotational force + var rotForce = Body_applyForce_rotForce; + relativePoint.cross(force,rotForce); + + // Add linear force + this.force.vadd(force,this.force); + + // Add rotational force + this.torque.vadd(rotForce,this.torque); +}; + +/** + * Apply force to a local point in the body. + * @method applyLocalForce + * @param {Vec3} force The force vector to apply, defined locally in the body frame. + * @param {Vec3} localPoint A local point in the body to apply the force on. + */ +var Body_applyLocalForce_worldForce = new Vec3(); +var Body_applyLocalForce_relativePointWorld = new Vec3(); +Body.prototype.applyLocalForce = function(localForce, localPoint){ + if(this.type !== Body.DYNAMIC){ + return; + } + + var worldForce = Body_applyLocalForce_worldForce; + var relativePointWorld = Body_applyLocalForce_relativePointWorld; + + // Transform the force vector to world space + this.vectorToWorldFrame(localForce, worldForce); + this.vectorToWorldFrame(localPoint, relativePointWorld); + + this.applyForce(worldForce, relativePointWorld); +}; + +/** + * Apply impulse to a world point. This could for example be a point on the Body surface. An impulse is a force added to a body during a short period of time (impulse = force * time). Impulses will be added to Body.velocity and Body.angularVelocity. + * @method applyImpulse + * @param {Vec3} impulse The amount of impulse to add. + * @param {Vec3} relativePoint A point relative to the center of mass to apply the force on. + */ +var Body_applyImpulse_r = new Vec3(); +var Body_applyImpulse_velo = new Vec3(); +var Body_applyImpulse_rotVelo = new Vec3(); +Body.prototype.applyImpulse = function(impulse, relativePoint){ + if(this.type !== Body.DYNAMIC){ + return; + } + + // Compute point position relative to the body center + var r = relativePoint; + + // Compute produced central impulse velocity + var velo = Body_applyImpulse_velo; + velo.copy(impulse); + velo.mult(this.invMass,velo); + + // Add linear impulse + this.velocity.vadd(velo, this.velocity); + + // Compute produced rotational impulse velocity + var rotVelo = Body_applyImpulse_rotVelo; + r.cross(impulse,rotVelo); + + /* + rotVelo.x *= this.invInertia.x; + rotVelo.y *= this.invInertia.y; + rotVelo.z *= this.invInertia.z; + */ + this.invInertiaWorld.vmult(rotVelo,rotVelo); + + // Add rotational Impulse + this.angularVelocity.vadd(rotVelo, this.angularVelocity); +}; + +/** + * Apply locally-defined impulse to a local point in the body. + * @method applyLocalImpulse + * @param {Vec3} force The force vector to apply, defined locally in the body frame. + * @param {Vec3} localPoint A local point in the body to apply the force on. + */ +var Body_applyLocalImpulse_worldImpulse = new Vec3(); +var Body_applyLocalImpulse_relativePoint = new Vec3(); +Body.prototype.applyLocalImpulse = function(localImpulse, localPoint){ + if(this.type !== Body.DYNAMIC){ + return; + } + + var worldImpulse = Body_applyLocalImpulse_worldImpulse; + var relativePointWorld = Body_applyLocalImpulse_relativePoint; + + // Transform the force vector to world space + this.vectorToWorldFrame(localImpulse, worldImpulse); + this.vectorToWorldFrame(localPoint, relativePointWorld); + + this.applyImpulse(worldImpulse, relativePointWorld); +}; + +var Body_updateMassProperties_halfExtents = new Vec3(); + +/** + * Should be called whenever you change the body shape or mass. + * @method updateMassProperties + */ +Body.prototype.updateMassProperties = function(){ + var halfExtents = Body_updateMassProperties_halfExtents; + + this.invMass = this.mass > 0 ? 1.0 / this.mass : 0; + var I = this.inertia; + var fixed = this.fixedRotation; + + // Approximate with AABB box + this.computeAABB(); + halfExtents.set( + (this.aabb.upperBound.x-this.aabb.lowerBound.x) / 2, + (this.aabb.upperBound.y-this.aabb.lowerBound.y) / 2, + (this.aabb.upperBound.z-this.aabb.lowerBound.z) / 2 + ); + Box.calculateInertia(halfExtents, this.mass, I); + + this.invInertia.set( + I.x > 0 && !fixed ? 1.0 / I.x : 0, + I.y > 0 && !fixed ? 1.0 / I.y : 0, + I.z > 0 && !fixed ? 1.0 / I.z : 0 + ); + this.updateInertiaWorld(true); +}; + +/** + * Get world velocity of a point in the body. + * @method getVelocityAtWorldPoint + * @param {Vec3} worldPoint + * @param {Vec3} result + * @return {Vec3} The result vector. + */ +Body.prototype.getVelocityAtWorldPoint = function(worldPoint, result){ + var r = new Vec3(); + worldPoint.vsub(this.position, r); + this.angularVelocity.cross(r, result); + this.velocity.vadd(result, result); + return result; +}; + +var torque = new Vec3(); +var invI_tau_dt = new Vec3(); +var w = new Quaternion(); +var wq = new Quaternion(); + +/** + * Move the body forward in time. + * @param {number} dt Time step + * @param {boolean} quatNormalize Set to true to normalize the body quaternion + * @param {boolean} quatNormalizeFast If the quaternion should be normalized using "fast" quaternion normalization + */ +Body.prototype.integrate = function(dt, quatNormalize, quatNormalizeFast){ + + // Save previous position + this.previousPosition.copy(this.position); + this.previousQuaternion.copy(this.quaternion); + + if(!(this.type === Body.DYNAMIC || this.type === Body.KINEMATIC) || this.sleepState === Body.SLEEPING){ // Only for dynamic + return; + } + + var velo = this.velocity, + angularVelo = this.angularVelocity, + pos = this.position, + force = this.force, + torque = this.torque, + quat = this.quaternion, + invMass = this.invMass, + invInertia = this.invInertiaWorld, + linearFactor = this.linearFactor; + + var iMdt = invMass * dt; + velo.x += force.x * iMdt * linearFactor.x; + velo.y += force.y * iMdt * linearFactor.y; + velo.z += force.z * iMdt * linearFactor.z; + + var e = invInertia.elements; + var angularFactor = this.angularFactor; + var tx = torque.x * angularFactor.x; + var ty = torque.y * angularFactor.y; + var tz = torque.z * angularFactor.z; + angularVelo.x += dt * (e[0] * tx + e[1] * ty + e[2] * tz); + angularVelo.y += dt * (e[3] * tx + e[4] * ty + e[5] * tz); + angularVelo.z += dt * (e[6] * tx + e[7] * ty + e[8] * tz); + + // Use new velocity - leap frog + pos.x += velo.x * dt; + pos.y += velo.y * dt; + pos.z += velo.z * dt; + + quat.integrate(this.angularVelocity, dt, this.angularFactor, quat); + + if(quatNormalize){ + if(quatNormalizeFast){ + quat.normalizeFast(); + } else { + quat.normalize(); + } + } + + this.aabbNeedsUpdate = true; + + // Update world inertia + this.updateInertiaWorld(); +}; + +},{"../collision/AABB":3,"../material/Material":26,"../math/Mat3":28,"../math/Quaternion":29,"../math/Vec3":31,"../shapes/Box":38,"../shapes/Shape":44,"../utils/EventTarget":50}],33:[function(require,module,exports){ +var Body = require('./Body'); +var Vec3 = require('../math/Vec3'); +var Quaternion = require('../math/Quaternion'); +var RaycastResult = require('../collision/RaycastResult'); +var Ray = require('../collision/Ray'); +var WheelInfo = require('../objects/WheelInfo'); + +module.exports = RaycastVehicle; + +/** + * Vehicle helper class that casts rays from the wheel positions towards the ground and applies forces. + * @class RaycastVehicle + * @constructor + * @param {object} [options] + * @param {Body} [options.chassisBody] The car chassis body. + * @param {integer} [options.indexRightAxis] Axis to use for right. x=0, y=1, z=2 + * @param {integer} [options.indexLeftAxis] + * @param {integer} [options.indexUpAxis] + */ +function RaycastVehicle(options){ + + /** + * @property {Body} chassisBody + */ + this.chassisBody = options.chassisBody; + + /** + * An array of WheelInfo objects. + * @property {array} wheelInfos + */ + this.wheelInfos = []; + + /** + * Will be set to true if the car is sliding. + * @property {boolean} sliding + */ + this.sliding = false; + + /** + * @property {World} world + */ + this.world = null; + + /** + * Index of the right axis, 0=x, 1=y, 2=z + * @property {integer} indexRightAxis + * @default 1 + */ + this.indexRightAxis = typeof(options.indexRightAxis) !== 'undefined' ? options.indexRightAxis : 1; + + /** + * Index of the forward axis, 0=x, 1=y, 2=z + * @property {integer} indexForwardAxis + * @default 0 + */ + this.indexForwardAxis = typeof(options.indexForwardAxis) !== 'undefined' ? options.indexForwardAxis : 0; + + /** + * Index of the up axis, 0=x, 1=y, 2=z + * @property {integer} indexUpAxis + * @default 2 + */ + this.indexUpAxis = typeof(options.indexUpAxis) !== 'undefined' ? options.indexUpAxis : 2; +} + +var tmpVec1 = new Vec3(); +var tmpVec2 = new Vec3(); +var tmpVec3 = new Vec3(); +var tmpVec4 = new Vec3(); +var tmpVec5 = new Vec3(); +var tmpVec6 = new Vec3(); +var tmpRay = new Ray(); + +/** + * Add a wheel. For information about the options, see WheelInfo. + * @method addWheel + * @param {object} [options] + */ +RaycastVehicle.prototype.addWheel = function(options){ + options = options || {}; + + var info = new WheelInfo(options); + var index = this.wheelInfos.length; + this.wheelInfos.push(info); + + return index; +}; + +/** + * Set the steering value of a wheel. + * @method setSteeringValue + * @param {number} value + * @param {integer} wheelIndex + */ +RaycastVehicle.prototype.setSteeringValue = function(value, wheelIndex){ + var wheel = this.wheelInfos[wheelIndex]; + wheel.steering = value; +}; + +var torque = new Vec3(); + +/** + * Set the wheel force to apply on one of the wheels each time step + * @method applyEngineForce + * @param {number} value + * @param {integer} wheelIndex + */ +RaycastVehicle.prototype.applyEngineForce = function(value, wheelIndex){ + this.wheelInfos[wheelIndex].engineForce = value; +}; + +/** + * Set the braking force of a wheel + * @method setBrake + * @param {number} brake + * @param {integer} wheelIndex + */ +RaycastVehicle.prototype.setBrake = function(brake, wheelIndex){ + this.wheelInfos[wheelIndex].brake = brake; +}; + +/** + * Add the vehicle including its constraints to the world. + * @method addToWorld + * @param {World} world + */ +RaycastVehicle.prototype.addToWorld = function(world){ + var constraints = this.constraints; + world.addBody(this.chassisBody); + var that = this; + this.preStepCallback = function(){ + that.updateVehicle(world.dt); + }; + world.addEventListener('preStep', this.preStepCallback); + this.world = world; +}; + +/** + * Get one of the wheel axles, world-oriented. + * @private + * @method getVehicleAxisWorld + * @param {integer} axisIndex + * @param {Vec3} result + */ +RaycastVehicle.prototype.getVehicleAxisWorld = function(axisIndex, result){ + result.set( + axisIndex === 0 ? 1 : 0, + axisIndex === 1 ? 1 : 0, + axisIndex === 2 ? 1 : 0 + ); + this.chassisBody.vectorToWorldFrame(result, result); +}; + +RaycastVehicle.prototype.updateVehicle = function(timeStep){ + var wheelInfos = this.wheelInfos; + var numWheels = wheelInfos.length; + var chassisBody = this.chassisBody; + + for (var i = 0; i < numWheels; i++) { + this.updateWheelTransform(i); + } + + this.currentVehicleSpeedKmHour = 3.6 * chassisBody.velocity.norm(); + + var forwardWorld = new Vec3(); + this.getVehicleAxisWorld(this.indexForwardAxis, forwardWorld); + + if (forwardWorld.dot(chassisBody.velocity) < 0){ + this.currentVehicleSpeedKmHour *= -1; + } + + // simulate suspension + for (var i = 0; i < numWheels; i++) { + this.castRay(wheelInfos[i]); + } + + this.updateSuspension(timeStep); + + var impulse = new Vec3(); + var relpos = new Vec3(); + for (var i = 0; i < numWheels; i++) { + //apply suspension force + var wheel = wheelInfos[i]; + var suspensionForce = wheel.suspensionForce; + if (suspensionForce > wheel.maxSuspensionForce) { + suspensionForce = wheel.maxSuspensionForce; + } + wheel.raycastResult.hitNormalWorld.scale(suspensionForce * timeStep, impulse); + + wheel.raycastResult.hitPointWorld.vsub(chassisBody.position, relpos); + chassisBody.applyImpulse(impulse, relpos); + } + + this.updateFriction(timeStep); + + var hitNormalWorldScaledWithProj = new Vec3(); + var fwd = new Vec3(); + var vel = new Vec3(); + for (i = 0; i < numWheels; i++) { + var wheel = wheelInfos[i]; + //var relpos = new Vec3(); + //wheel.chassisConnectionPointWorld.vsub(chassisBody.position, relpos); + chassisBody.getVelocityAtWorldPoint(wheel.chassisConnectionPointWorld, vel); + + // Hack to get the rotation in the correct direction + var m = 1; + switch(this.indexUpAxis){ + case 1: + m = -1; + break; + } + + if (wheel.isInContact) { + + this.getVehicleAxisWorld(this.indexForwardAxis, fwd); + var proj = fwd.dot(wheel.raycastResult.hitNormalWorld); + wheel.raycastResult.hitNormalWorld.scale(proj, hitNormalWorldScaledWithProj); + + fwd.vsub(hitNormalWorldScaledWithProj, fwd); + + var proj2 = fwd.dot(vel); + wheel.deltaRotation = m * proj2 * timeStep / wheel.radius; + } + + if((wheel.sliding || !wheel.isInContact) && wheel.engineForce !== 0 && wheel.useCustomSlidingRotationalSpeed){ + // Apply custom rotation when accelerating and sliding + wheel.deltaRotation = (wheel.engineForce > 0 ? 1 : -1) * wheel.customSlidingRotationalSpeed * timeStep; + } + + // Lock wheels + if(Math.abs(wheel.brake) > Math.abs(wheel.engineForce)){ + wheel.deltaRotation = 0; + } + + wheel.rotation += wheel.deltaRotation; // Use the old value + wheel.deltaRotation *= 0.99; // damping of rotation when not in contact + } +}; + +RaycastVehicle.prototype.updateSuspension = function(deltaTime) { + var chassisBody = this.chassisBody; + var chassisMass = chassisBody.mass; + var wheelInfos = this.wheelInfos; + var numWheels = wheelInfos.length; + + for (var w_it = 0; w_it < numWheels; w_it++){ + var wheel = wheelInfos[w_it]; + + if (wheel.isInContact){ + var force; + + // Spring + var susp_length = wheel.suspensionRestLength; + var current_length = wheel.suspensionLength; + var length_diff = (susp_length - current_length); + + force = wheel.suspensionStiffness * length_diff * wheel.clippedInvContactDotSuspension; + + // Damper + var projected_rel_vel = wheel.suspensionRelativeVelocity; + var susp_damping; + if (projected_rel_vel < 0) { + susp_damping = wheel.dampingCompression; + } else { + susp_damping = wheel.dampingRelaxation; + } + force -= susp_damping * projected_rel_vel; + + wheel.suspensionForce = force * chassisMass; + if (wheel.suspensionForce < 0) { + wheel.suspensionForce = 0; + } + } else { + wheel.suspensionForce = 0; + } + } +}; + +/** + * Remove the vehicle including its constraints from the world. + * @method removeFromWorld + * @param {World} world + */ +RaycastVehicle.prototype.removeFromWorld = function(world){ + var constraints = this.constraints; + world.remove(this.chassisBody); + world.removeEventListener('preStep', this.preStepCallback); + this.world = null; +}; + +var castRay_rayvector = new Vec3(); +var castRay_target = new Vec3(); +RaycastVehicle.prototype.castRay = function(wheel) { + var rayvector = castRay_rayvector; + var target = castRay_target; + + this.updateWheelTransformWorld(wheel); + var chassisBody = this.chassisBody; + + var depth = -1; + + var raylen = wheel.suspensionRestLength + wheel.radius; + + wheel.directionWorld.scale(raylen, rayvector); + var source = wheel.chassisConnectionPointWorld; + source.vadd(rayvector, target); + var raycastResult = wheel.raycastResult; + + var param = 0; + + raycastResult.reset(); + // Turn off ray collision with the chassis temporarily + var oldState = chassisBody.collisionResponse; + chassisBody.collisionResponse = false; + + // Cast ray against world + this.world.rayTest(source, target, raycastResult); + chassisBody.collisionResponse = oldState; + + var object = raycastResult.body; + + wheel.raycastResult.groundObject = 0; + + if (object) { + depth = raycastResult.distance; + wheel.raycastResult.hitNormalWorld = raycastResult.hitNormalWorld; + wheel.isInContact = true; + + var hitDistance = raycastResult.distance; + wheel.suspensionLength = hitDistance - wheel.radius; + + // clamp on max suspension travel + var minSuspensionLength = wheel.suspensionRestLength - wheel.maxSuspensionTravel; + var maxSuspensionLength = wheel.suspensionRestLength + wheel.maxSuspensionTravel; + if (wheel.suspensionLength < minSuspensionLength) { + wheel.suspensionLength = minSuspensionLength; + } + if (wheel.suspensionLength > maxSuspensionLength) { + wheel.suspensionLength = maxSuspensionLength; + wheel.raycastResult.reset(); + } + + var denominator = wheel.raycastResult.hitNormalWorld.dot(wheel.directionWorld); + + var chassis_velocity_at_contactPoint = new Vec3(); + chassisBody.getVelocityAtWorldPoint(wheel.raycastResult.hitPointWorld, chassis_velocity_at_contactPoint); + + var projVel = wheel.raycastResult.hitNormalWorld.dot( chassis_velocity_at_contactPoint ); + + if (denominator >= -0.1) { + wheel.suspensionRelativeVelocity = 0; + wheel.clippedInvContactDotSuspension = 1 / 0.1; + } else { + var inv = -1 / denominator; + wheel.suspensionRelativeVelocity = projVel * inv; + wheel.clippedInvContactDotSuspension = inv; + } + + } else { + + //put wheel info as in rest position + wheel.suspensionLength = wheel.suspensionRestLength + 0 * wheel.maxSuspensionTravel; + wheel.suspensionRelativeVelocity = 0.0; + wheel.directionWorld.scale(-1, wheel.raycastResult.hitNormalWorld); + wheel.clippedInvContactDotSuspension = 1.0; + } + + return depth; +}; + +RaycastVehicle.prototype.updateWheelTransformWorld = function(wheel){ + wheel.isInContact = false; + var chassisBody = this.chassisBody; + chassisBody.pointToWorldFrame(wheel.chassisConnectionPointLocal, wheel.chassisConnectionPointWorld); + chassisBody.vectorToWorldFrame(wheel.directionLocal, wheel.directionWorld); + chassisBody.vectorToWorldFrame(wheel.axleLocal, wheel.axleWorld); +}; + + +/** + * Update one of the wheel transform. + * Note when rendering wheels: during each step, wheel transforms are updated BEFORE the chassis; ie. their position becomes invalid after the step. Thus when you render wheels, you must update wheel transforms before rendering them. See raycastVehicle demo for an example. + * @method updateWheelTransform + * @param {integer} wheelIndex The wheel index to update. + */ +RaycastVehicle.prototype.updateWheelTransform = function(wheelIndex){ + var up = tmpVec4; + var right = tmpVec5; + var fwd = tmpVec6; + + var wheel = this.wheelInfos[wheelIndex]; + this.updateWheelTransformWorld(wheel); + + wheel.directionLocal.scale(-1, up); + right.copy(wheel.axleLocal); + up.cross(right, fwd); + fwd.normalize(); + right.normalize(); + + // Rotate around steering over the wheelAxle + var steering = wheel.steering; + var steeringOrn = new Quaternion(); + steeringOrn.setFromAxisAngle(up, steering); + + var rotatingOrn = new Quaternion(); + rotatingOrn.setFromAxisAngle(right, wheel.rotation); + + // World rotation of the wheel + var q = wheel.worldTransform.quaternion; + this.chassisBody.quaternion.mult(steeringOrn, q); + q.mult(rotatingOrn, q); + + q.normalize(); + + // world position of the wheel + var p = wheel.worldTransform.position; + p.copy(wheel.directionWorld); + p.scale(wheel.suspensionLength, p); + p.vadd(wheel.chassisConnectionPointWorld, p); +}; + +var directions = [ + new Vec3(1, 0, 0), + new Vec3(0, 1, 0), + new Vec3(0, 0, 1) +]; + +/** + * Get the world transform of one of the wheels + * @method getWheelTransformWorld + * @param {integer} wheelIndex + * @return {Transform} + */ +RaycastVehicle.prototype.getWheelTransformWorld = function(wheelIndex) { + return this.wheelInfos[wheelIndex].worldTransform; +}; + + +var updateFriction_surfNormalWS_scaled_proj = new Vec3(); +var updateFriction_axle = []; +var updateFriction_forwardWS = []; +var sideFrictionStiffness2 = 1; +RaycastVehicle.prototype.updateFriction = function(timeStep) { + var surfNormalWS_scaled_proj = updateFriction_surfNormalWS_scaled_proj; + + //calculate the impulse, so that the wheels don't move sidewards + var wheelInfos = this.wheelInfos; + var numWheels = wheelInfos.length; + var chassisBody = this.chassisBody; + var forwardWS = updateFriction_forwardWS; + var axle = updateFriction_axle; + + var numWheelsOnGround = 0; + + for (var i = 0; i < numWheels; i++) { + var wheel = wheelInfos[i]; + + var groundObject = wheel.raycastResult.body; + if (groundObject){ + numWheelsOnGround++; + } + + wheel.sideImpulse = 0; + wheel.forwardImpulse = 0; + if(!forwardWS[i]){ + forwardWS[i] = new Vec3(); + } + if(!axle[i]){ + axle[i] = new Vec3(); + } + } + + for (var i = 0; i < numWheels; i++){ + var wheel = wheelInfos[i]; + + var groundObject = wheel.raycastResult.body; + + if (groundObject) { + var axlei = axle[i]; + var wheelTrans = this.getWheelTransformWorld(i); + + // Get world axle + wheelTrans.vectorToWorldFrame(directions[this.indexRightAxis], axlei); + + var surfNormalWS = wheel.raycastResult.hitNormalWorld; + var proj = axlei.dot(surfNormalWS); + surfNormalWS.scale(proj, surfNormalWS_scaled_proj); + axlei.vsub(surfNormalWS_scaled_proj, axlei); + axlei.normalize(); + + surfNormalWS.cross(axlei, forwardWS[i]); + forwardWS[i].normalize(); + + wheel.sideImpulse = resolveSingleBilateral( + chassisBody, + wheel.raycastResult.hitPointWorld, + groundObject, + wheel.raycastResult.hitPointWorld, + axlei + ); + + wheel.sideImpulse *= sideFrictionStiffness2; + } + } + + var sideFactor = 1; + var fwdFactor = 0.5; + + this.sliding = false; + for (var i = 0; i < numWheels; i++) { + var wheel = wheelInfos[i]; + var groundObject = wheel.raycastResult.body; + + var rollingFriction = 0; + + wheel.slipInfo = 1; + if (groundObject) { + var defaultRollingFrictionImpulse = 0; + var maxImpulse = wheel.brake ? wheel.brake : defaultRollingFrictionImpulse; + + // btWheelContactPoint contactPt(chassisBody,groundObject,wheelInfraycastInfo.hitPointWorld,forwardWS[wheel],maxImpulse); + // rollingFriction = calcRollingFriction(contactPt); + rollingFriction = calcRollingFriction(chassisBody, groundObject, wheel.raycastResult.hitPointWorld, forwardWS[i], maxImpulse); + + rollingFriction += wheel.engineForce * timeStep; + + // rollingFriction = 0; + var factor = maxImpulse / rollingFriction; + wheel.slipInfo *= factor; + } + + //switch between active rolling (throttle), braking and non-active rolling friction (nthrottle/break) + + wheel.forwardImpulse = 0; + wheel.skidInfo = 1; + + if (groundObject) { + wheel.skidInfo = 1; + + var maximp = wheel.suspensionForce * timeStep * wheel.frictionSlip; + var maximpSide = maximp; + + var maximpSquared = maximp * maximpSide; + + wheel.forwardImpulse = rollingFriction;//wheelInfo.engineForce* timeStep; + + var x = wheel.forwardImpulse * fwdFactor; + var y = wheel.sideImpulse * sideFactor; + + var impulseSquared = x * x + y * y; + + wheel.sliding = false; + if (impulseSquared > maximpSquared) { + this.sliding = true; + wheel.sliding = true; + + var factor = maximp / Math.sqrt(impulseSquared); + + wheel.skidInfo *= factor; + } + } + } + + if (this.sliding) { + for (var i = 0; i < numWheels; i++) { + var wheel = wheelInfos[i]; + if (wheel.sideImpulse !== 0) { + if (wheel.skidInfo < 1){ + wheel.forwardImpulse *= wheel.skidInfo; + wheel.sideImpulse *= wheel.skidInfo; + } + } + } + } + + // apply the impulses + for (var i = 0; i < numWheels; i++) { + var wheel = wheelInfos[i]; + + var rel_pos = new Vec3(); + wheel.raycastResult.hitPointWorld.vsub(chassisBody.position, rel_pos); + // cannons applyimpulse is using world coord for the position + //rel_pos.copy(wheel.raycastResult.hitPointWorld); + + if (wheel.forwardImpulse !== 0) { + var impulse = new Vec3(); + forwardWS[i].scale(wheel.forwardImpulse, impulse); + chassisBody.applyImpulse(impulse, rel_pos); + } + + if (wheel.sideImpulse !== 0){ + var groundObject = wheel.raycastResult.body; + + var rel_pos2 = new Vec3(); + wheel.raycastResult.hitPointWorld.vsub(groundObject.position, rel_pos2); + //rel_pos2.copy(wheel.raycastResult.hitPointWorld); + var sideImp = new Vec3(); + axle[i].scale(wheel.sideImpulse, sideImp); + + // Scale the relative position in the up direction with rollInfluence. + // If rollInfluence is 1, the impulse will be applied on the hitPoint (easy to roll over), if it is zero it will be applied in the same plane as the center of mass (not easy to roll over). + chassisBody.vectorToLocalFrame(rel_pos, rel_pos); + rel_pos['xyz'[this.indexUpAxis]] *= wheel.rollInfluence; + chassisBody.vectorToWorldFrame(rel_pos, rel_pos); + chassisBody.applyImpulse(sideImp, rel_pos); + + //apply friction impulse on the ground + sideImp.scale(-1, sideImp); + groundObject.applyImpulse(sideImp, rel_pos2); + } + } +}; + +var calcRollingFriction_vel1 = new Vec3(); +var calcRollingFriction_vel2 = new Vec3(); +var calcRollingFriction_vel = new Vec3(); + +function calcRollingFriction(body0, body1, frictionPosWorld, frictionDirectionWorld, maxImpulse) { + var j1 = 0; + var contactPosWorld = frictionPosWorld; + + // var rel_pos1 = new Vec3(); + // var rel_pos2 = new Vec3(); + var vel1 = calcRollingFriction_vel1; + var vel2 = calcRollingFriction_vel2; + var vel = calcRollingFriction_vel; + // contactPosWorld.vsub(body0.position, rel_pos1); + // contactPosWorld.vsub(body1.position, rel_pos2); + + body0.getVelocityAtWorldPoint(contactPosWorld, vel1); + body1.getVelocityAtWorldPoint(contactPosWorld, vel2); + vel1.vsub(vel2, vel); + + var vrel = frictionDirectionWorld.dot(vel); + + var denom0 = computeImpulseDenominator(body0, frictionPosWorld, frictionDirectionWorld); + var denom1 = computeImpulseDenominator(body1, frictionPosWorld, frictionDirectionWorld); + var relaxation = 1; + var jacDiagABInv = relaxation / (denom0 + denom1); + + // calculate j that moves us to zero relative velocity + j1 = -vrel * jacDiagABInv; + + if (maxImpulse < j1) { + j1 = maxImpulse; + } + if (j1 < -maxImpulse) { + j1 = -maxImpulse; + } + + return j1; +} + +var computeImpulseDenominator_r0 = new Vec3(); +var computeImpulseDenominator_c0 = new Vec3(); +var computeImpulseDenominator_vec = new Vec3(); +var computeImpulseDenominator_m = new Vec3(); +function computeImpulseDenominator(body, pos, normal) { + var r0 = computeImpulseDenominator_r0; + var c0 = computeImpulseDenominator_c0; + var vec = computeImpulseDenominator_vec; + var m = computeImpulseDenominator_m; + + pos.vsub(body.position, r0); + r0.cross(normal, c0); + body.invInertiaWorld.vmult(c0, m); + m.cross(r0, vec); + + return body.invMass + normal.dot(vec); +} + + +var resolveSingleBilateral_vel1 = new Vec3(); +var resolveSingleBilateral_vel2 = new Vec3(); +var resolveSingleBilateral_vel = new Vec3(); + +//bilateral constraint between two dynamic objects +function resolveSingleBilateral(body1, pos1, body2, pos2, normal, impulse){ + var normalLenSqr = normal.norm2(); + if (normalLenSqr > 1.1){ + return 0; // no impulse + } + // var rel_pos1 = new Vec3(); + // var rel_pos2 = new Vec3(); + // pos1.vsub(body1.position, rel_pos1); + // pos2.vsub(body2.position, rel_pos2); + + var vel1 = resolveSingleBilateral_vel1; + var vel2 = resolveSingleBilateral_vel2; + var vel = resolveSingleBilateral_vel; + body1.getVelocityAtWorldPoint(pos1, vel1); + body2.getVelocityAtWorldPoint(pos2, vel2); + + vel1.vsub(vel2, vel); + + var rel_vel = normal.dot(vel); + + var contactDamping = 0.2; + var massTerm = 1 / (body1.invMass + body2.invMass); + var impulse = - contactDamping * rel_vel * massTerm; + + return impulse; +} +},{"../collision/Ray":10,"../collision/RaycastResult":11,"../math/Quaternion":29,"../math/Vec3":31,"../objects/WheelInfo":37,"./Body":32}],34:[function(require,module,exports){ +var Body = require('./Body'); +var Sphere = require('../shapes/Sphere'); +var Box = require('../shapes/Box'); +var Vec3 = require('../math/Vec3'); +var HingeConstraint = require('../constraints/HingeConstraint'); + +module.exports = RigidVehicle; + +/** + * Simple vehicle helper class with spherical rigid body wheels. + * @class RigidVehicle + * @constructor + * @param {Body} [options.chassisBody] + */ +function RigidVehicle(options){ + this.wheelBodies = []; + + /** + * @property coordinateSystem + * @type {Vec3} + */ + this.coordinateSystem = typeof(options.coordinateSystem)==='undefined' ? new Vec3(1, 2, 3) : options.coordinateSystem.clone(); + + /** + * @property {Body} chassisBody + */ + this.chassisBody = options.chassisBody; + + if(!this.chassisBody){ + // No chassis body given. Create it! + var chassisShape = new Box(new Vec3(5, 2, 0.5)); + this.chassisBody = new Body(1, chassisShape); + } + + /** + * @property constraints + * @type {Array} + */ + this.constraints = []; + + this.wheelAxes = []; + this.wheelForces = []; +} + +/** + * Add a wheel + * @method addWheel + * @param {object} options + * @param {boolean} [options.isFrontWheel] + * @param {Vec3} [options.position] Position of the wheel, locally in the chassis body. + * @param {Vec3} [options.direction] Slide direction of the wheel along the suspension. + * @param {Vec3} [options.axis] Axis of rotation of the wheel, locally defined in the chassis. + * @param {Body} [options.body] The wheel body. + */ +RigidVehicle.prototype.addWheel = function(options){ + options = options || {}; + var wheelBody = options.body; + if(!wheelBody){ + wheelBody = new Body(1, new Sphere(1.2)); + } + this.wheelBodies.push(wheelBody); + this.wheelForces.push(0); + + // Position constrain wheels + var zero = new Vec3(); + var position = typeof(options.position) !== 'undefined' ? options.position.clone() : new Vec3(); + + // Set position locally to the chassis + var worldPosition = new Vec3(); + this.chassisBody.pointToWorldFrame(position, worldPosition); + wheelBody.position.set(worldPosition.x, worldPosition.y, worldPosition.z); + + // Constrain wheel + var axis = typeof(options.axis) !== 'undefined' ? options.axis.clone() : new Vec3(0, 1, 0); + this.wheelAxes.push(axis); + + var hingeConstraint = new HingeConstraint(this.chassisBody, wheelBody, { + pivotA: position, + axisA: axis, + pivotB: Vec3.ZERO, + axisB: axis, + collideConnected: false + }); + this.constraints.push(hingeConstraint); + + return this.wheelBodies.length - 1; +}; + +/** + * Set the steering value of a wheel. + * @method setSteeringValue + * @param {number} value + * @param {integer} wheelIndex + * @todo check coordinateSystem + */ +RigidVehicle.prototype.setSteeringValue = function(value, wheelIndex){ + // Set angle of the hinge axis + var axis = this.wheelAxes[wheelIndex]; + + var c = Math.cos(value), + s = Math.sin(value), + x = axis.x, + y = axis.y; + this.constraints[wheelIndex].axisA.set( + c*x -s*y, + s*x +c*y, + 0 + ); +}; + +/** + * Set the target rotational speed of the hinge constraint. + * @method setMotorSpeed + * @param {number} value + * @param {integer} wheelIndex + */ +RigidVehicle.prototype.setMotorSpeed = function(value, wheelIndex){ + var hingeConstraint = this.constraints[wheelIndex]; + hingeConstraint.enableMotor(); + hingeConstraint.motorTargetVelocity = value; +}; + +/** + * Set the target rotational speed of the hinge constraint. + * @method disableMotor + * @param {number} value + * @param {integer} wheelIndex + */ +RigidVehicle.prototype.disableMotor = function(wheelIndex){ + var hingeConstraint = this.constraints[wheelIndex]; + hingeConstraint.disableMotor(); +}; + +var torque = new Vec3(); + +/** + * Set the wheel force to apply on one of the wheels each time step + * @method setWheelForce + * @param {number} value + * @param {integer} wheelIndex + */ +RigidVehicle.prototype.setWheelForce = function(value, wheelIndex){ + this.wheelForces[wheelIndex] = value; +}; + +/** + * Apply a torque on one of the wheels. + * @method applyWheelForce + * @param {number} value + * @param {integer} wheelIndex + */ +RigidVehicle.prototype.applyWheelForce = function(value, wheelIndex){ + var axis = this.wheelAxes[wheelIndex]; + var wheelBody = this.wheelBodies[wheelIndex]; + var bodyTorque = wheelBody.torque; + + axis.scale(value, torque); + wheelBody.vectorToWorldFrame(torque, torque); + bodyTorque.vadd(torque, bodyTorque); +}; + +/** + * Add the vehicle including its constraints to the world. + * @method addToWorld + * @param {World} world + */ +RigidVehicle.prototype.addToWorld = function(world){ + var constraints = this.constraints; + var bodies = this.wheelBodies.concat([this.chassisBody]); + + for (var i = 0; i < bodies.length; i++) { + world.addBody(bodies[i]); + } + + for (var i = 0; i < constraints.length; i++) { + world.addConstraint(constraints[i]); + } + + world.addEventListener('preStep', this._update.bind(this)); +}; + +RigidVehicle.prototype._update = function(){ + var wheelForces = this.wheelForces; + for (var i = 0; i < wheelForces.length; i++) { + this.applyWheelForce(wheelForces[i], i); + } +}; + +/** + * Remove the vehicle including its constraints from the world. + * @method removeFromWorld + * @param {World} world + */ +RigidVehicle.prototype.removeFromWorld = function(world){ + var constraints = this.constraints; + var bodies = this.wheelBodies.concat([this.chassisBody]); + + for (var i = 0; i < bodies.length; i++) { + world.remove(bodies[i]); + } + + for (var i = 0; i < constraints.length; i++) { + world.removeConstraint(constraints[i]); + } +}; + +var worldAxis = new Vec3(); + +/** + * Get current rotational velocity of a wheel + * @method getWheelSpeed + * @param {integer} wheelIndex + */ +RigidVehicle.prototype.getWheelSpeed = function(wheelIndex){ + var axis = this.wheelAxes[wheelIndex]; + var wheelBody = this.wheelBodies[wheelIndex]; + var w = wheelBody.angularVelocity; + this.chassisBody.vectorToWorldFrame(axis, worldAxis); + return w.dot(worldAxis); +}; + +},{"../constraints/HingeConstraint":16,"../math/Vec3":31,"../shapes/Box":38,"../shapes/Sphere":45,"./Body":32}],35:[function(require,module,exports){ +module.exports = SPHSystem; + +var Shape = require('../shapes/Shape'); +var Vec3 = require('../math/Vec3'); +var Quaternion = require('../math/Quaternion'); +var Particle = require('../shapes/Particle'); +var Body = require('../objects/Body'); +var Material = require('../material/Material'); + +/** + * Smoothed-particle hydrodynamics system + * @class SPHSystem + * @constructor + */ +function SPHSystem(){ + this.particles = []; + + /** + * Density of the system (kg/m3). + * @property {number} density + */ + this.density = 1; + + /** + * Distance below which two particles are considered to be neighbors. + * It should be adjusted so there are about 15-20 neighbor particles within this radius. + * @property {number} smoothingRadius + */ + this.smoothingRadius = 1; + this.speedOfSound = 1; + + /** + * Viscosity of the system. + * @property {number} viscosity + */ + this.viscosity = 0.01; + this.eps = 0.000001; + + // Stuff Computed per particle + this.pressures = []; + this.densities = []; + this.neighbors = []; +} + +/** + * Add a particle to the system. + * @method add + * @param {Body} particle + */ +SPHSystem.prototype.add = function(particle){ + this.particles.push(particle); + if(this.neighbors.length < this.particles.length){ + this.neighbors.push([]); + } +}; + +/** + * Remove a particle from the system. + * @method remove + * @param {Body} particle + */ +SPHSystem.prototype.remove = function(particle){ + var idx = this.particles.indexOf(particle); + if(idx !== -1){ + this.particles.splice(idx,1); + if(this.neighbors.length > this.particles.length){ + this.neighbors.pop(); + } + } +}; + +/** + * Get neighbors within smoothing volume, save in the array neighbors + * @method getNeighbors + * @param {Body} particle + * @param {Array} neighbors + */ +var SPHSystem_getNeighbors_dist = new Vec3(); +SPHSystem.prototype.getNeighbors = function(particle,neighbors){ + var N = this.particles.length, + id = particle.id, + R2 = this.smoothingRadius * this.smoothingRadius, + dist = SPHSystem_getNeighbors_dist; + for(var i=0; i!==N; i++){ + var p = this.particles[i]; + p.position.vsub(particle.position,dist); + if(id!==p.id && dist.norm2() < R2){ + neighbors.push(p); + } + } +}; + +// Temp vectors for calculation +var SPHSystem_update_dist = new Vec3(), + SPHSystem_update_a_pressure = new Vec3(), + SPHSystem_update_a_visc = new Vec3(), + SPHSystem_update_gradW = new Vec3(), + SPHSystem_update_r_vec = new Vec3(), + SPHSystem_update_u = new Vec3(); // Relative velocity +SPHSystem.prototype.update = function(){ + var N = this.particles.length, + dist = SPHSystem_update_dist, + cs = this.speedOfSound, + eps = this.eps; + + for(var i=0; i!==N; i++){ + var p = this.particles[i]; // Current particle + var neighbors = this.neighbors[i]; + + // Get neighbors + neighbors.length = 0; + this.getNeighbors(p,neighbors); + neighbors.push(this.particles[i]); // Add current too + var numNeighbors = neighbors.length; + + // Accumulate density for the particle + var sum = 0.0; + for(var j=0; j!==numNeighbors; j++){ + + //printf("Current particle has position %f %f %f\n",objects[id].pos.x(),objects[id].pos.y(),objects[id].pos.z()); + p.position.vsub(neighbors[j].position, dist); + var len = dist.norm(); + + var weight = this.w(len); + sum += neighbors[j].mass * weight; + } + + // Save + this.densities[i] = sum; + this.pressures[i] = cs * cs * (this.densities[i] - this.density); + } + + // Add forces + + // Sum to these accelerations + var a_pressure= SPHSystem_update_a_pressure; + var a_visc = SPHSystem_update_a_visc; + var gradW = SPHSystem_update_gradW; + var r_vec = SPHSystem_update_r_vec; + var u = SPHSystem_update_u; + + for(var i=0; i!==N; i++){ + + var particle = this.particles[i]; + + a_pressure.set(0,0,0); + a_visc.set(0,0,0); + + // Init vars + var Pij; + var nabla; + var Vij; + + // Sum up for all other neighbors + var neighbors = this.neighbors[i]; + var numNeighbors = neighbors.length; + + //printf("Neighbors: "); + for(var j=0; j!==numNeighbors; j++){ + + var neighbor = neighbors[j]; + //printf("%d ",nj); + + // Get r once for all.. + particle.position.vsub(neighbor.position,r_vec); + var r = r_vec.norm(); + + // Pressure contribution + Pij = -neighbor.mass * (this.pressures[i] / (this.densities[i]*this.densities[i] + eps) + this.pressures[j] / (this.densities[j]*this.densities[j] + eps)); + this.gradw(r_vec, gradW); + // Add to pressure acceleration + gradW.mult(Pij , gradW); + a_pressure.vadd(gradW, a_pressure); + + // Viscosity contribution + neighbor.velocity.vsub(particle.velocity, u); + u.mult( 1.0 / (0.0001+this.densities[i] * this.densities[j]) * this.viscosity * neighbor.mass , u ); + nabla = this.nablaw(r); + u.mult(nabla,u); + // Add to viscosity acceleration + a_visc.vadd( u, a_visc ); + } + + // Calculate force + a_visc.mult(particle.mass, a_visc); + a_pressure.mult(particle.mass, a_pressure); + + // Add force to particles + particle.force.vadd(a_visc, particle.force); + particle.force.vadd(a_pressure, particle.force); + } +}; + +// Calculate the weight using the W(r) weightfunction +SPHSystem.prototype.w = function(r){ + // 315 + var h = this.smoothingRadius; + return 315.0/(64.0*Math.PI*Math.pow(h,9)) * Math.pow(h*h-r*r,3); +}; + +// calculate gradient of the weight function +SPHSystem.prototype.gradw = function(rVec,resultVec){ + var r = rVec.norm(), + h = this.smoothingRadius; + rVec.mult(945.0/(32.0*Math.PI*Math.pow(h,9)) * Math.pow((h*h-r*r),2) , resultVec); +}; + +// Calculate nabla(W) +SPHSystem.prototype.nablaw = function(r){ + var h = this.smoothingRadius; + var nabla = 945.0/(32.0*Math.PI*Math.pow(h,9)) * (h*h-r*r)*(7*r*r - 3*h*h); + return nabla; +}; + +},{"../material/Material":26,"../math/Quaternion":29,"../math/Vec3":31,"../objects/Body":32,"../shapes/Particle":42,"../shapes/Shape":44}],36:[function(require,module,exports){ +var Vec3 = require('../math/Vec3'); + +module.exports = Spring; + +/** + * A spring, connecting two bodies. + * + * @class Spring + * @constructor + * @param {Body} bodyA + * @param {Body} bodyB + * @param {Object} [options] + * @param {number} [options.restLength] A number > 0. Default: 1 + * @param {number} [options.stiffness] A number >= 0. Default: 100 + * @param {number} [options.damping] A number >= 0. Default: 1 + * @param {Vec3} [options.worldAnchorA] Where to hook the spring to body A, in world coordinates. + * @param {Vec3} [options.worldAnchorB] + * @param {Vec3} [options.localAnchorA] Where to hook the spring to body A, in local body coordinates. + * @param {Vec3} [options.localAnchorB] + */ +function Spring(bodyA,bodyB,options){ + options = options || {}; + + /** + * Rest length of the spring. + * @property restLength + * @type {number} + */ + this.restLength = typeof(options.restLength) === "number" ? options.restLength : 1; + + /** + * Stiffness of the spring. + * @property stiffness + * @type {number} + */ + this.stiffness = options.stiffness || 100; + + /** + * Damping of the spring. + * @property damping + * @type {number} + */ + this.damping = options.damping || 1; + + /** + * First connected body. + * @property bodyA + * @type {Body} + */ + this.bodyA = bodyA; + + /** + * Second connected body. + * @property bodyB + * @type {Body} + */ + this.bodyB = bodyB; + + /** + * Anchor for bodyA in local bodyA coordinates. + * @property localAnchorA + * @type {Vec3} + */ + this.localAnchorA = new Vec3(); + + /** + * Anchor for bodyB in local bodyB coordinates. + * @property localAnchorB + * @type {Vec3} + */ + this.localAnchorB = new Vec3(); + + if(options.localAnchorA){ + this.localAnchorA.copy(options.localAnchorA); + } + if(options.localAnchorB){ + this.localAnchorB.copy(options.localAnchorB); + } + if(options.worldAnchorA){ + this.setWorldAnchorA(options.worldAnchorA); + } + if(options.worldAnchorB){ + this.setWorldAnchorB(options.worldAnchorB); + } +} + +/** + * Set the anchor point on body A, using world coordinates. + * @method setWorldAnchorA + * @param {Vec3} worldAnchorA + */ +Spring.prototype.setWorldAnchorA = function(worldAnchorA){ + this.bodyA.pointToLocalFrame(worldAnchorA,this.localAnchorA); +}; + +/** + * Set the anchor point on body B, using world coordinates. + * @method setWorldAnchorB + * @param {Vec3} worldAnchorB + */ +Spring.prototype.setWorldAnchorB = function(worldAnchorB){ + this.bodyB.pointToLocalFrame(worldAnchorB,this.localAnchorB); +}; + +/** + * Get the anchor point on body A, in world coordinates. + * @method getWorldAnchorA + * @param {Vec3} result The vector to store the result in. + */ +Spring.prototype.getWorldAnchorA = function(result){ + this.bodyA.pointToWorldFrame(this.localAnchorA,result); +}; + +/** + * Get the anchor point on body B, in world coordinates. + * @method getWorldAnchorB + * @param {Vec3} result The vector to store the result in. + */ +Spring.prototype.getWorldAnchorB = function(result){ + this.bodyB.pointToWorldFrame(this.localAnchorB,result); +}; + +var applyForce_r = new Vec3(), + applyForce_r_unit = new Vec3(), + applyForce_u = new Vec3(), + applyForce_f = new Vec3(), + applyForce_worldAnchorA = new Vec3(), + applyForce_worldAnchorB = new Vec3(), + applyForce_ri = new Vec3(), + applyForce_rj = new Vec3(), + applyForce_ri_x_f = new Vec3(), + applyForce_rj_x_f = new Vec3(), + applyForce_tmp = new Vec3(); + +/** + * Apply the spring force to the connected bodies. + * @method applyForce + */ +Spring.prototype.applyForce = function(){ + var k = this.stiffness, + d = this.damping, + l = this.restLength, + bodyA = this.bodyA, + bodyB = this.bodyB, + r = applyForce_r, + r_unit = applyForce_r_unit, + u = applyForce_u, + f = applyForce_f, + tmp = applyForce_tmp; + + var worldAnchorA = applyForce_worldAnchorA, + worldAnchorB = applyForce_worldAnchorB, + ri = applyForce_ri, + rj = applyForce_rj, + ri_x_f = applyForce_ri_x_f, + rj_x_f = applyForce_rj_x_f; + + // Get world anchors + this.getWorldAnchorA(worldAnchorA); + this.getWorldAnchorB(worldAnchorB); + + // Get offset points + worldAnchorA.vsub(bodyA.position,ri); + worldAnchorB.vsub(bodyB.position,rj); + + // Compute distance vector between world anchor points + worldAnchorB.vsub(worldAnchorA,r); + var rlen = r.norm(); + r_unit.copy(r); + r_unit.normalize(); + + // Compute relative velocity of the anchor points, u + bodyB.velocity.vsub(bodyA.velocity,u); + // Add rotational velocity + + bodyB.angularVelocity.cross(rj,tmp); + u.vadd(tmp,u); + bodyA.angularVelocity.cross(ri,tmp); + u.vsub(tmp,u); + + // F = - k * ( x - L ) - D * ( u ) + r_unit.mult(-k*(rlen-l) - d*u.dot(r_unit), f); + + // Add forces to bodies + bodyA.force.vsub(f,bodyA.force); + bodyB.force.vadd(f,bodyB.force); + + // Angular force + ri.cross(f,ri_x_f); + rj.cross(f,rj_x_f); + bodyA.torque.vsub(ri_x_f,bodyA.torque); + bodyB.torque.vadd(rj_x_f,bodyB.torque); +}; + +},{"../math/Vec3":31}],37:[function(require,module,exports){ +var Vec3 = require('../math/Vec3'); +var Transform = require('../math/Transform'); +var RaycastResult = require('../collision/RaycastResult'); +var Utils = require('../utils/Utils'); + +module.exports = WheelInfo; + +/** + * @class WheelInfo + * @constructor + * @param {Object} [options] + * + * @param {Vec3} [options.chassisConnectionPointLocal] + * @param {Vec3} [options.chassisConnectionPointWorld] + * @param {Vec3} [options.directionLocal] + * @param {Vec3} [options.directionWorld] + * @param {Vec3} [options.axleLocal] + * @param {Vec3} [options.axleWorld] + * @param {number} [options.suspensionRestLength=1] + * @param {number} [options.suspensionMaxLength=2] + * @param {number} [options.radius=1] + * @param {number} [options.suspensionStiffness=100] + * @param {number} [options.dampingCompression=10] + * @param {number} [options.dampingRelaxation=10] + * @param {number} [options.frictionSlip=10000] + * @param {number} [options.steering=0] + * @param {number} [options.rotation=0] + * @param {number} [options.deltaRotation=0] + * @param {number} [options.rollInfluence=0.01] + * @param {number} [options.maxSuspensionForce] + * @param {boolean} [options.isFrontWheel=true] + * @param {number} [options.clippedInvContactDotSuspension=1] + * @param {number} [options.suspensionRelativeVelocity=0] + * @param {number} [options.suspensionForce=0] + * @param {number} [options.skidInfo=0] + * @param {number} [options.suspensionLength=0] + * @param {number} [options.maxSuspensionTravel=1] + * @param {boolean} [options.useCustomSlidingRotationalSpeed=false] + * @param {number} [options.customSlidingRotationalSpeed=-0.1] + */ +function WheelInfo(options){ + options = Utils.defaults(options, { + chassisConnectionPointLocal: new Vec3(), + chassisConnectionPointWorld: new Vec3(), + directionLocal: new Vec3(), + directionWorld: new Vec3(), + axleLocal: new Vec3(), + axleWorld: new Vec3(), + suspensionRestLength: 1, + suspensionMaxLength: 2, + radius: 1, + suspensionStiffness: 100, + dampingCompression: 10, + dampingRelaxation: 10, + frictionSlip: 10000, + steering: 0, + rotation: 0, + deltaRotation: 0, + rollInfluence: 0.01, + maxSuspensionForce: Number.MAX_VALUE, + isFrontWheel: true, + clippedInvContactDotSuspension: 1, + suspensionRelativeVelocity: 0, + suspensionForce: 0, + skidInfo: 0, + suspensionLength: 0, + maxSuspensionTravel: 1, + useCustomSlidingRotationalSpeed: false, + customSlidingRotationalSpeed: -0.1 + }); + + /** + * Max travel distance of the suspension, in meters. + * @property {number} maxSuspensionTravel + */ + this.maxSuspensionTravel = options.maxSuspensionTravel; + + /** + * Speed to apply to the wheel rotation when the wheel is sliding. + * @property {number} customSlidingRotationalSpeed + */ + this.customSlidingRotationalSpeed = options.customSlidingRotationalSpeed; + + /** + * If the customSlidingRotationalSpeed should be used. + * @property {Boolean} useCustomSlidingRotationalSpeed + */ + this.useCustomSlidingRotationalSpeed = options.useCustomSlidingRotationalSpeed; + + /** + * @property {Boolean} sliding + */ + this.sliding = false; + + /** + * Connection point, defined locally in the chassis body frame. + * @property {Vec3} chassisConnectionPointLocal + */ + this.chassisConnectionPointLocal = options.chassisConnectionPointLocal.clone(); + + /** + * @property {Vec3} chassisConnectionPointWorld + */ + this.chassisConnectionPointWorld = options.chassisConnectionPointWorld.clone(); + + /** + * @property {Vec3} directionLocal + */ + this.directionLocal = options.directionLocal.clone(); + + /** + * @property {Vec3} directionWorld + */ + this.directionWorld = options.directionWorld.clone(); + + /** + * @property {Vec3} axleLocal + */ + this.axleLocal = options.axleLocal.clone(); + + /** + * @property {Vec3} axleWorld + */ + this.axleWorld = options.axleWorld.clone(); + + /** + * @property {number} suspensionRestLength + */ + this.suspensionRestLength = options.suspensionRestLength; + + /** + * @property {number} suspensionMaxLength + */ + this.suspensionMaxLength = options.suspensionMaxLength; + + /** + * @property {number} radius + */ + this.radius = options.radius; + + /** + * @property {number} suspensionStiffness + */ + this.suspensionStiffness = options.suspensionStiffness; + + /** + * @property {number} dampingCompression + */ + this.dampingCompression = options.dampingCompression; + + /** + * @property {number} dampingRelaxation + */ + this.dampingRelaxation = options.dampingRelaxation; + + /** + * @property {number} frictionSlip + */ + this.frictionSlip = options.frictionSlip; + + /** + * @property {number} steering + */ + this.steering = 0; + + /** + * Rotation value, in radians. + * @property {number} rotation + */ + this.rotation = 0; + + /** + * @property {number} deltaRotation + */ + this.deltaRotation = 0; + + /** + * @property {number} rollInfluence + */ + this.rollInfluence = options.rollInfluence; + + /** + * @property {number} maxSuspensionForce + */ + this.maxSuspensionForce = options.maxSuspensionForce; + + /** + * @property {number} engineForce + */ + this.engineForce = 0; + + /** + * @property {number} brake + */ + this.brake = 0; + + /** + * @property {number} isFrontWheel + */ + this.isFrontWheel = options.isFrontWheel; + + /** + * @property {number} clippedInvContactDotSuspension + */ + this.clippedInvContactDotSuspension = 1; + + /** + * @property {number} suspensionRelativeVelocity + */ + this.suspensionRelativeVelocity = 0; + + /** + * @property {number} suspensionForce + */ + this.suspensionForce = 0; + + /** + * @property {number} skidInfo + */ + this.skidInfo = 0; + + /** + * @property {number} suspensionLength + */ + this.suspensionLength = 0; + + /** + * @property {number} sideImpulse + */ + this.sideImpulse = 0; + + /** + * @property {number} forwardImpulse + */ + this.forwardImpulse = 0; + + /** + * The result from raycasting + * @property {RaycastResult} raycastResult + */ + this.raycastResult = new RaycastResult(); + + /** + * Wheel world transform + * @property {Transform} worldTransform + */ + this.worldTransform = new Transform(); + + /** + * @property {boolean} isInContact + */ + this.isInContact = false; +} + +var chassis_velocity_at_contactPoint = new Vec3(); +var relpos = new Vec3(); +var chassis_velocity_at_contactPoint = new Vec3(); +WheelInfo.prototype.updateWheel = function(chassis){ + var raycastResult = this.raycastResult; + + if (this.isInContact){ + var project= raycastResult.hitNormalWorld.dot(raycastResult.directionWorld); + raycastResult.hitPointWorld.vsub(chassis.position, relpos); + chassis.getVelocityAtWorldPoint(relpos, chassis_velocity_at_contactPoint); + var projVel = raycastResult.hitNormalWorld.dot( chassis_velocity_at_contactPoint ); + if (project >= -0.1) { + this.suspensionRelativeVelocity = 0.0; + this.clippedInvContactDotSuspension = 1.0 / 0.1; + } else { + var inv = -1 / project; + this.suspensionRelativeVelocity = projVel * inv; + this.clippedInvContactDotSuspension = inv; + } + + } else { + // Not in contact : position wheel in a nice (rest length) position + raycastResult.suspensionLength = this.suspensionRestLength; + this.suspensionRelativeVelocity = 0.0; + raycastResult.directionWorld.scale(-1, raycastResult.hitNormalWorld); + this.clippedInvContactDotSuspension = 1.0; + } +}; +},{"../collision/RaycastResult":11,"../math/Transform":30,"../math/Vec3":31,"../utils/Utils":54}],38:[function(require,module,exports){ +module.exports = Box; + +var Shape = require('./Shape'); +var Vec3 = require('../math/Vec3'); +var ConvexPolyhedron = require('./ConvexPolyhedron'); + +/** + * A 3d box shape. + * @class Box + * @constructor + * @param {Vec3} halfExtents + * @author schteppe + * @extends Shape + */ +function Box(halfExtents){ + Shape.call(this, { + type: Shape.types.BOX + }); + + /** + * @property halfExtents + * @type {Vec3} + */ + this.halfExtents = halfExtents; + + /** + * Used by the contact generator to make contacts with other convex polyhedra for example + * @property convexPolyhedronRepresentation + * @type {ConvexPolyhedron} + */ + this.convexPolyhedronRepresentation = null; + + this.updateConvexPolyhedronRepresentation(); + this.updateBoundingSphereRadius(); +} +Box.prototype = new Shape(); +Box.prototype.constructor = Box; + +/** + * Updates the local convex polyhedron representation used for some collisions. + * @method updateConvexPolyhedronRepresentation + */ +Box.prototype.updateConvexPolyhedronRepresentation = function(){ + var sx = this.halfExtents.x; + var sy = this.halfExtents.y; + var sz = this.halfExtents.z; + var V = Vec3; + + var vertices = [ + new V(-sx,-sy,-sz), + new V( sx,-sy,-sz), + new V( sx, sy,-sz), + new V(-sx, sy,-sz), + new V(-sx,-sy, sz), + new V( sx,-sy, sz), + new V( sx, sy, sz), + new V(-sx, sy, sz) + ]; + + var indices = [ + [3,2,1,0], // -z + [4,5,6,7], // +z + [5,4,0,1], // -y + [2,3,7,6], // +y + [0,4,7,3], // -x + [1,2,6,5], // +x + ]; + + var axes = [ + new V(0, 0, 1), + new V(0, 1, 0), + new V(1, 0, 0) + ]; + + var h = new ConvexPolyhedron(vertices, indices); + this.convexPolyhedronRepresentation = h; + h.material = this.material; +}; + +/** + * @method calculateLocalInertia + * @param {Number} mass + * @param {Vec3} target + * @return {Vec3} + */ +Box.prototype.calculateLocalInertia = function(mass,target){ + target = target || new Vec3(); + Box.calculateInertia(this.halfExtents, mass, target); + return target; +}; + +Box.calculateInertia = function(halfExtents,mass,target){ + var e = halfExtents; + target.x = 1.0 / 12.0 * mass * ( 2*e.y*2*e.y + 2*e.z*2*e.z ); + target.y = 1.0 / 12.0 * mass * ( 2*e.x*2*e.x + 2*e.z*2*e.z ); + target.z = 1.0 / 12.0 * mass * ( 2*e.y*2*e.y + 2*e.x*2*e.x ); +}; + +/** + * Get the box 6 side normals + * @method getSideNormals + * @param {array} sixTargetVectors An array of 6 vectors, to store the resulting side normals in. + * @param {Quaternion} quat Orientation to apply to the normal vectors. If not provided, the vectors will be in respect to the local frame. + * @return {array} + */ +Box.prototype.getSideNormals = function(sixTargetVectors,quat){ + var sides = sixTargetVectors; + var ex = this.halfExtents; + sides[0].set( ex.x, 0, 0); + sides[1].set( 0, ex.y, 0); + sides[2].set( 0, 0, ex.z); + sides[3].set( -ex.x, 0, 0); + sides[4].set( 0, -ex.y, 0); + sides[5].set( 0, 0, -ex.z); + + if(quat!==undefined){ + for(var i=0; i!==sides.length; i++){ + quat.vmult(sides[i],sides[i]); + } + } + + return sides; +}; + +Box.prototype.volume = function(){ + return 8.0 * this.halfExtents.x * this.halfExtents.y * this.halfExtents.z; +}; + +Box.prototype.updateBoundingSphereRadius = function(){ + this.boundingSphereRadius = this.halfExtents.norm(); +}; + +var worldCornerTempPos = new Vec3(); +var worldCornerTempNeg = new Vec3(); +Box.prototype.forEachWorldCorner = function(pos,quat,callback){ + + var e = this.halfExtents; + var corners = [[ e.x, e.y, e.z], + [ -e.x, e.y, e.z], + [ -e.x, -e.y, e.z], + [ -e.x, -e.y, -e.z], + [ e.x, -e.y, -e.z], + [ e.x, e.y, -e.z], + [ -e.x, e.y, -e.z], + [ e.x, -e.y, e.z]]; + for(var i=0; i max.x){ + max.x = x; + } + if(y > max.y){ + max.y = y; + } + if(z > max.z){ + max.z = z; + } + + if(x < min.x){ + min.x = x; + } + if(y < min.y){ + min.y = y; + } + if(z < min.z){ + min.z = z; + } + } + + // Get each axis max + // min.set(Infinity,Infinity,Infinity); + // max.set(-Infinity,-Infinity,-Infinity); + // this.forEachWorldCorner(pos,quat,function(x,y,z){ + // if(x > max.x){ + // max.x = x; + // } + // if(y > max.y){ + // max.y = y; + // } + // if(z > max.z){ + // max.z = z; + // } + + // if(x < min.x){ + // min.x = x; + // } + // if(y < min.y){ + // min.y = y; + // } + // if(z < min.z){ + // min.z = z; + // } + // }); +}; + +},{"../math/Vec3":31,"./ConvexPolyhedron":39,"./Shape":44}],39:[function(require,module,exports){ +module.exports = ConvexPolyhedron; + +var Shape = require('./Shape'); +var Vec3 = require('../math/Vec3'); +var Quaternion = require('../math/Quaternion'); +var Transform = require('../math/Transform'); + +/** + * A set of polygons describing a convex shape. + * @class ConvexPolyhedron + * @constructor + * @extends Shape + * @description The shape MUST be convex for the code to work properly. No polygons may be coplanar (contained + * in the same 3D plane), instead these should be merged into one polygon. + * + * @param {array} points An array of Vec3's + * @param {array} faces Array of integer arrays, describing which vertices that is included in each face. + * + * @author qiao / https://github.com/qiao (original author, see https://github.com/qiao/three.js/commit/85026f0c769e4000148a67d45a9e9b9c5108836f) + * @author schteppe / https://github.com/schteppe + * @see http://www.altdevblogaday.com/2011/05/13/contact-generation-between-3d-convex-meshes/ + * @see http://bullet.googlecode.com/svn/trunk/src/BulletCollision/NarrowPhaseCollision/btPolyhedralContactClipping.cpp + * + * @todo Move the clipping functions to ContactGenerator? + * @todo Automatically merge coplanar polygons in constructor. + */ +function ConvexPolyhedron(points, faces, uniqueAxes) { + Shape.call(this, { + type: Shape.types.CONVEXPOLYHEDRON + }); + + /** + * Array of Vec3 + * @property vertices + * @type {Array} + */ + this.vertices = points||[]; + + this.worldVertices = []; // World transformed version of .vertices + this.worldVerticesNeedsUpdate = true; + + /** + * Array of integer arrays, indicating which vertices each face consists of + * @property faces + * @type {Array} + */ + this.faces = faces||[]; + + /** + * Array of Vec3 + * @property faceNormals + * @type {Array} + */ + this.faceNormals = []; + this.computeNormals(); + + this.worldFaceNormalsNeedsUpdate = true; + this.worldFaceNormals = []; // World transformed version of .faceNormals + + /** + * Array of Vec3 + * @property uniqueEdges + * @type {Array} + */ + this.uniqueEdges = []; + + /** + * If given, these locally defined, normalized axes are the only ones being checked when doing separating axis check. + * @property {Array} uniqueAxes + */ + this.uniqueAxes = uniqueAxes ? uniqueAxes.slice() : null; + + this.computeEdges(); + this.updateBoundingSphereRadius(); +} +ConvexPolyhedron.prototype = new Shape(); +ConvexPolyhedron.prototype.constructor = ConvexPolyhedron; + +var computeEdges_tmpEdge = new Vec3(); +/** + * Computes uniqueEdges + * @method computeEdges + */ +ConvexPolyhedron.prototype.computeEdges = function(){ + var faces = this.faces; + var vertices = this.vertices; + var nv = vertices.length; + var edges = this.uniqueEdges; + + edges.length = 0; + + var edge = computeEdges_tmpEdge; + + for(var i=0; i !== faces.length; i++){ + var face = faces[i]; + var numVertices = face.length; + for(var j = 0; j !== numVertices; j++){ + var k = ( j+1 ) % numVertices; + vertices[face[j]].vsub(vertices[face[k]], edge); + edge.normalize(); + var found = false; + for(var p=0; p !== edges.length; p++){ + if (edges[p].almostEquals(edge) || edges[p].almostEquals(edge)){ + found = true; + break; + } + } + + if (!found){ + edges.push(edge.clone()); + } + } + } +}; + +/** + * Compute the normals of the faces. Will reuse existing Vec3 objects in the .faceNormals array if they exist. + * @method computeNormals + */ +ConvexPolyhedron.prototype.computeNormals = function(){ + this.faceNormals.length = this.faces.length; + + // Generate normals + for(var i=0; i dmax){ + dmax = d; + closestFaceB = face; + } + } + var worldVertsB1 = []; + var polyB = hullB.faces[closestFaceB]; + var numVertices = polyB.length; + for(var e0=0; e0=0){ + this.clipFaceAgainstHull(separatingNormal, + posA, + quatA, + worldVertsB1, + minDist, + maxDist, + result); + } +}; + +/** + * Find the separating axis between this hull and another + * @method findSeparatingAxis + * @param {ConvexPolyhedron} hullB + * @param {Vec3} posA + * @param {Quaternion} quatA + * @param {Vec3} posB + * @param {Quaternion} quatB + * @param {Vec3} target The target vector to save the axis in + * @return {bool} Returns false if a separation is found, else true + */ +var fsa_faceANormalWS3 = new Vec3(), + fsa_Worldnormal1 = new Vec3(), + fsa_deltaC = new Vec3(), + fsa_worldEdge0 = new Vec3(), + fsa_worldEdge1 = new Vec3(), + fsa_Cross = new Vec3(); +ConvexPolyhedron.prototype.findSeparatingAxis = function(hullB,posA,quatA,posB,quatB,target, faceListA, faceListB){ + var faceANormalWS3 = fsa_faceANormalWS3, + Worldnormal1 = fsa_Worldnormal1, + deltaC = fsa_deltaC, + worldEdge0 = fsa_worldEdge0, + worldEdge1 = fsa_worldEdge1, + Cross = fsa_Cross; + + var dmin = Number.MAX_VALUE; + var hullA = this; + var curPlaneTests=0; + + if(!hullA.uniqueAxes){ + + var numFacesA = faceListA ? faceListA.length : hullA.faces.length; + + // Test face normals from hullA + for(var i=0; i0.0){ + target.negate(target); + } + + return true; +}; + +var maxminA=[], maxminB=[]; + +/** + * Test separating axis against two hulls. Both hulls are projected onto the axis and the overlap size is returned if there is one. + * @method testSepAxis + * @param {Vec3} axis + * @param {ConvexPolyhedron} hullB + * @param {Vec3} posA + * @param {Quaternion} quatA + * @param {Vec3} posB + * @param {Quaternion} quatB + * @return {number} The overlap depth, or FALSE if no penetration. + */ +ConvexPolyhedron.prototype.testSepAxis = function(axis, hullB, posA, quatA, posB, quatB){ + var hullA=this; + ConvexPolyhedron.project(hullA, axis, posA, quatA, maxminA); + ConvexPolyhedron.project(hullB, axis, posB, quatB, maxminB); + var maxA = maxminA[0]; + var minA = maxminA[1]; + var maxB = maxminB[0]; + var minB = maxminB[1]; + if(maxA= 0, so output intersection + var newv = new Vec3(); + firstVertex.lerp(lastVertex, + n_dot_first / (n_dot_first - n_dot_last), + newv); + outVertices.push(newv); + } + } else { + if(n_dot_last<0){ + // Start >= 0, end < 0 so output intersection and end + var newv = new Vec3(); + firstVertex.lerp(lastVertex, + n_dot_first / (n_dot_first - n_dot_last), + newv); + outVertices.push(newv); + outVertices.push(lastVertex); + } + } + firstVertex = lastVertex; + n_dot_first = n_dot_last; + } + return outVertices; +}; + +// Updates .worldVertices and sets .worldVerticesNeedsUpdate to false. +ConvexPolyhedron.prototype.computeWorldVertices = function(position,quat){ + var N = this.vertices.length; + while(this.worldVertices.length < N){ + this.worldVertices.push( new Vec3() ); + } + + var verts = this.vertices, + worldVerts = this.worldVertices; + for(var i=0; i!==N; i++){ + quat.vmult( verts[i] , worldVerts[i] ); + position.vadd( worldVerts[i] , worldVerts[i] ); + } + + this.worldVerticesNeedsUpdate = false; +}; + +var computeLocalAABB_worldVert = new Vec3(); +ConvexPolyhedron.prototype.computeLocalAABB = function(aabbmin,aabbmax){ + var n = this.vertices.length, + vertices = this.vertices, + worldVert = computeLocalAABB_worldVert; + + aabbmin.set(Number.MAX_VALUE, Number.MAX_VALUE, Number.MAX_VALUE); + aabbmax.set(-Number.MAX_VALUE, -Number.MAX_VALUE, -Number.MAX_VALUE); + + for(var i=0; i aabbmax.x){ + aabbmax.x = v.x; + } + if (v.y < aabbmin.y){ + aabbmin.y = v.y; + } else if(v.y > aabbmax.y){ + aabbmax.y = v.y; + } + if (v.z < aabbmin.z){ + aabbmin.z = v.z; + } else if(v.z > aabbmax.z){ + aabbmax.z = v.z; + } + } +}; + +/** + * Updates .worldVertices and sets .worldVerticesNeedsUpdate to false. + * @method computeWorldFaceNormals + * @param {Quaternion} quat + */ +ConvexPolyhedron.prototype.computeWorldFaceNormals = function(quat){ + var N = this.faceNormals.length; + while(this.worldFaceNormals.length < N){ + this.worldFaceNormals.push( new Vec3() ); + } + + var normals = this.faceNormals, + worldNormals = this.worldFaceNormals; + for(var i=0; i!==N; i++){ + quat.vmult( normals[i] , worldNormals[i] ); + } + + this.worldFaceNormalsNeedsUpdate = false; +}; + +/** + * @method updateBoundingSphereRadius + */ +ConvexPolyhedron.prototype.updateBoundingSphereRadius = function(){ + // Assume points are distributed with local (0,0,0) as center + var max2 = 0; + var verts = this.vertices; + for(var i=0, N=verts.length; i!==N; i++) { + var norm2 = verts[i].norm2(); + if(norm2 > max2){ + max2 = norm2; + } + } + this.boundingSphereRadius = Math.sqrt(max2); +}; + +var tempWorldVertex = new Vec3(); + +/** + * @method calculateWorldAABB + * @param {Vec3} pos + * @param {Quaternion} quat + * @param {Vec3} min + * @param {Vec3} max + */ +ConvexPolyhedron.prototype.calculateWorldAABB = function(pos,quat,min,max){ + var n = this.vertices.length, verts = this.vertices; + var minx,miny,minz,maxx,maxy,maxz; + for(var i=0; i maxx || maxx===undefined){ + maxx = v.x; + } + + if (v.y < miny || miny===undefined){ + miny = v.y; + } else if(v.y > maxy || maxy===undefined){ + maxy = v.y; + } + + if (v.z < minz || minz===undefined){ + minz = v.z; + } else if(v.z > maxz || maxz===undefined){ + maxz = v.z; + } + } + min.set(minx,miny,minz); + max.set(maxx,maxy,maxz); +}; + +/** + * Get approximate convex volume + * @method volume + * @return {Number} + */ +ConvexPolyhedron.prototype.volume = function(){ + return 4.0 * Math.PI * this.boundingSphereRadius / 3.0; +}; + +/** + * Get an average of all the vertices positions + * @method getAveragePointLocal + * @param {Vec3} target + * @return {Vec3} + */ +ConvexPolyhedron.prototype.getAveragePointLocal = function(target){ + target = target || new Vec3(); + var n = this.vertices.length, + verts = this.vertices; + for(var i=0; i0) || (r1>0 && r2<0)){ + return false; // Encountered some other sign. Exit. + } else { + } + } + + // If we got here, all dot products were of the same sign. + return positiveResult ? 1 : -1; +}; + +/** + * Get max and min dot product of a convex hull at position (pos,quat) projected onto an axis. Results are saved in the array maxmin. + * @static + * @method project + * @param {ConvexPolyhedron} hull + * @param {Vec3} axis + * @param {Vec3} pos + * @param {Quaternion} quat + * @param {array} result result[0] and result[1] will be set to maximum and minimum, respectively. + */ +var project_worldVertex = new Vec3(); +var project_localAxis = new Vec3(); +var project_localOrigin = new Vec3(); +ConvexPolyhedron.project = function(hull, axis, pos, quat, result){ + var n = hull.vertices.length, + worldVertex = project_worldVertex, + localAxis = project_localAxis, + max = 0, + min = 0, + localOrigin = project_localOrigin, + vs = hull.vertices; + + localOrigin.setZero(); + + // Transform the axis to local + Transform.vectorToLocalFrame(pos, quat, axis, localAxis); + Transform.pointToLocalFrame(pos, quat, localOrigin, localOrigin); + var add = localOrigin.dot(localAxis); + + min = max = vs[0].dot(localAxis); + + for(var i = 1; i < n; i++){ + var val = vs[i].dot(localAxis); + + if(val > max){ + max = val; + } + + if(val < min){ + min = val; + } + } + + min -= add; + max -= add; + + if(min > max){ + // Inconsistent - swap + var temp = min; + min = max; + max = temp; + } + // Output + result[0] = max; + result[1] = min; +}; + +},{"../math/Quaternion":29,"../math/Transform":30,"../math/Vec3":31,"./Shape":44}],40:[function(require,module,exports){ +module.exports = Cylinder; + +var Shape = require('./Shape'); +var Vec3 = require('../math/Vec3'); +var Quaternion = require('../math/Quaternion'); +var ConvexPolyhedron = require('./ConvexPolyhedron'); + +/** + * @class Cylinder + * @constructor + * @extends ConvexPolyhedron + * @author schteppe / https://github.com/schteppe + * @param {Number} radiusTop + * @param {Number} radiusBottom + * @param {Number} height + * @param {Number} numSegments The number of segments to build the cylinder out of + */ +function Cylinder( radiusTop, radiusBottom, height , numSegments ) { + var N = numSegments, + verts = [], + axes = [], + faces = [], + bottomface = [], + topface = [], + cos = Math.cos, + sin = Math.sin; + + // First bottom point + verts.push(new Vec3(radiusBottom*cos(0), + radiusBottom*sin(0), + -height*0.5)); + bottomface.push(0); + + // First top point + verts.push(new Vec3(radiusTop*cos(0), + radiusTop*sin(0), + height*0.5)); + topface.push(1); + + for(var i=0; i { convex: ..., offset: ... } + // for example: + // _cachedPillars["0_2_1"] + this._cachedPillars = {}; +} +Heightfield.prototype = new Shape(); + +/** + * Call whenever you change the data array. + * @method update + */ +Heightfield.prototype.update = function(){ + this._cachedPillars = {}; +}; + +/** + * Update the .minValue property + * @method updateMinValue + */ +Heightfield.prototype.updateMinValue = function(){ + var data = this.data; + var minValue = data[0][0]; + for(var i=0; i !== data.length; i++){ + for(var j=0; j !== data[i].length; j++){ + var v = data[i][j]; + if(v < minValue){ + minValue = v; + } + } + } + this.minValue = minValue; +}; + +/** + * Update the .maxValue property + * @method updateMaxValue + */ +Heightfield.prototype.updateMaxValue = function(){ + var data = this.data; + var maxValue = data[0][0]; + for(var i=0; i !== data.length; i++){ + for(var j=0; j !== data[i].length; j++){ + var v = data[i][j]; + if(v > maxValue){ + maxValue = v; + } + } + } + this.maxValue = maxValue; +}; + +/** + * Set the height value at an index. Don't forget to update maxValue and minValue after you're done. + * @method setHeightValueAtIndex + * @param {integer} xi + * @param {integer} yi + * @param {number} value + */ +Heightfield.prototype.setHeightValueAtIndex = function(xi, yi, value){ + var data = this.data; + data[xi][yi] = value; + + // Invalidate cache + this.clearCachedConvexTrianglePillar(xi, yi, false); + if(xi > 0){ + this.clearCachedConvexTrianglePillar(xi - 1, yi, true); + this.clearCachedConvexTrianglePillar(xi - 1, yi, false); + } + if(yi > 0){ + this.clearCachedConvexTrianglePillar(xi, yi - 1, true); + this.clearCachedConvexTrianglePillar(xi, yi - 1, false); + } + if(yi > 0 && xi > 0){ + this.clearCachedConvexTrianglePillar(xi - 1, yi - 1, true); + } +}; + +/** + * Get max/min in a rectangle in the matrix data + * @method getRectMinMax + * @param {integer} iMinX + * @param {integer} iMinY + * @param {integer} iMaxX + * @param {integer} iMaxY + * @param {array} [result] An array to store the results in. + * @return {array} The result array, if it was passed in. Minimum will be at position 0 and max at 1. + */ +Heightfield.prototype.getRectMinMax = function (iMinX, iMinY, iMaxX, iMaxY, result) { + result = result || []; + + // Get max and min of the data + var data = this.data, + max = this.minValue; // Set first value + for(var i = iMinX; i <= iMaxX; i++){ + for(var j = iMinY; j <= iMaxY; j++){ + var height = data[i][j]; + if(height > max){ + max = height; + } + } + } + + result[0] = this.minValue; + result[1] = max; +}; + + + +/** + * Get the index of a local position on the heightfield. The indexes indicate the rectangles, so if your terrain is made of N x N height data points, you will have rectangle indexes ranging from 0 to N-1. + * @method getIndexOfPosition + * @param {number} x + * @param {number} y + * @param {array} result Two-element array + * @param {boolean} clamp If the position should be clamped to the heightfield edge. + * @return {boolean} + */ +Heightfield.prototype.getIndexOfPosition = function (x, y, result, clamp) { + + // Get the index of the data points to test against + var w = this.elementSize; + var data = this.data; + var xi = Math.floor(x / w); + var yi = Math.floor(y / w); + + result[0] = xi; + result[1] = yi; + + if(clamp){ + // Clamp index to edges + if(xi < 0){ xi = 0; } + if(yi < 0){ yi = 0; } + if(xi >= data.length - 1){ xi = data.length - 1; } + if(yi >= data[0].length - 1){ yi = data[0].length - 1; } + } + + // Bail out if we are out of the terrain + if(xi < 0 || yi < 0 || xi >= data.length-1 || yi >= data[0].length-1){ + return false; + } + + return true; +}; + + +var getHeightAt_idx = []; +var getHeightAt_weights = new Vec3(); +var getHeightAt_a = new Vec3(); +var getHeightAt_b = new Vec3(); +var getHeightAt_c = new Vec3(); + +Heightfield.prototype.getTriangleAt = function(x, y, edgeClamp, a, b, c){ + var idx = getHeightAt_idx; + this.getIndexOfPosition(x, y, idx, edgeClamp); + var xi = idx[0]; + var yi = idx[1]; + + var data = this.data; + if(edgeClamp){ + xi = Math.min(data.length - 2, Math.max(0, xi)); + yi = Math.min(data[0].length - 2, Math.max(0, yi)); + } + + var elementSize = this.elementSize; + var lowerDist2 = Math.pow(x / elementSize - xi, 2) + Math.pow(y / elementSize - yi, 2); + var upperDist2 = Math.pow(x / elementSize - (xi + 1), 2) + Math.pow(y / elementSize - (yi + 1), 2); + var upper = lowerDist2 > upperDist2; + this.getTriangle(xi, yi, upper, a, b, c); + return upper; +}; + +var getNormalAt_a = new Vec3(); +var getNormalAt_b = new Vec3(); +var getNormalAt_c = new Vec3(); +var getNormalAt_e0 = new Vec3(); +var getNormalAt_e1 = new Vec3(); +Heightfield.prototype.getNormalAt = function(x, y, edgeClamp, result){ + var a = getNormalAt_a; + var b = getNormalAt_b; + var c = getNormalAt_c; + var e0 = getNormalAt_e0; + var e1 = getNormalAt_e1; + this.getTriangleAt(x, y, edgeClamp, a, b, c); + b.vsub(a, e0); + c.vsub(a, e1); + e0.cross(e1, result); + result.normalize(); +}; + + +/** + * Get an AABB of a square in the heightfield + * @param {number} xi + * @param {number} yi + * @param {AABB} result + */ +Heightfield.prototype.getAabbAtIndex = function(xi, yi, result){ + var data = this.data; + var elementSize = this.elementSize; + + result.lowerBound.set( + xi * elementSize, + yi * elementSize, + data[xi][yi] + ); + result.upperBound.set( + (xi + 1) * elementSize, + (yi + 1) * elementSize, + data[xi + 1][yi + 1] + ); +}; + + +/** + * Get the height in the heightfield at a given position + * @param {number} x + * @param {number} y + * @param {boolean} edgeClamp + * @return {number} + */ +Heightfield.prototype.getHeightAt = function(x, y, edgeClamp){ + var data = this.data; + var a = getHeightAt_a; + var b = getHeightAt_b; + var c = getHeightAt_c; + var idx = getHeightAt_idx; + + this.getIndexOfPosition(x, y, idx, edgeClamp); + var xi = idx[0]; + var yi = idx[1]; + if(edgeClamp){ + xi = Math.min(data.length - 2, Math.max(0, xi)); + yi = Math.min(data[0].length - 2, Math.max(0, yi)); + } + var upper = this.getTriangleAt(x, y, edgeClamp, a, b, c); + barycentricWeights(x, y, a.x, a.y, b.x, b.y, c.x, c.y, getHeightAt_weights); + + var w = getHeightAt_weights; + + if(upper){ + + // Top triangle verts + return data[xi + 1][yi + 1] * w.x + data[xi][yi + 1] * w.y + data[xi + 1][yi] * w.z; + + } else { + + // Top triangle verts + return data[xi][yi] * w.x + data[xi + 1][yi] * w.y + data[xi][yi + 1] * w.z; + } +}; + +// from https://en.wikipedia.org/wiki/Barycentric_coordinate_system +function barycentricWeights(x, y, ax, ay, bx, by, cx, cy, result){ + result.x = ((by - cy) * (x - cx) + (cx - bx) * (y - cy)) / ((by - cy) * (ax - cx) + (cx - bx) * (ay - cy)); + result.y = ((cy - ay) * (x - cx) + (ax - cx) * (y - cy)) / ((by - cy) * (ax - cx) + (cx - bx) * (ay - cy)); + result.z = 1 - result.x - result.y; +} + +Heightfield.prototype.getCacheConvexTrianglePillarKey = function(xi, yi, getUpperTriangle){ + return xi + '_' + yi + '_' + (getUpperTriangle ? 1 : 0); +}; + +Heightfield.prototype.getCachedConvexTrianglePillar = function(xi, yi, getUpperTriangle){ + return this._cachedPillars[this.getCacheConvexTrianglePillarKey(xi, yi, getUpperTriangle)]; +}; + +Heightfield.prototype.setCachedConvexTrianglePillar = function(xi, yi, getUpperTriangle, convex, offset){ + this._cachedPillars[this.getCacheConvexTrianglePillarKey(xi, yi, getUpperTriangle)] = { + convex: convex, + offset: offset + }; +}; + +Heightfield.prototype.clearCachedConvexTrianglePillar = function(xi, yi, getUpperTriangle){ + delete this._cachedPillars[this.getCacheConvexTrianglePillarKey(xi, yi, getUpperTriangle)]; +}; + +/** + * Get a triangle from the heightfield + * @param {number} xi + * @param {number} yi + * @param {boolean} upper + * @param {Vec3} a + * @param {Vec3} b + * @param {Vec3} c + */ +Heightfield.prototype.getTriangle = function(xi, yi, upper, a, b, c){ + var data = this.data; + var elementSize = this.elementSize; + + if(upper){ + + // Top triangle verts + a.set( + (xi + 1) * elementSize, + (yi + 1) * elementSize, + data[xi + 1][yi + 1] + ); + b.set( + xi * elementSize, + (yi + 1) * elementSize, + data[xi][yi + 1] + ); + c.set( + (xi + 1) * elementSize, + yi * elementSize, + data[xi + 1][yi] + ); + + } else { + + // Top triangle verts + a.set( + xi * elementSize, + yi * elementSize, + data[xi][yi] + ); + b.set( + (xi + 1) * elementSize, + yi * elementSize, + data[xi + 1][yi] + ); + c.set( + xi * elementSize, + (yi + 1) * elementSize, + data[xi][yi + 1] + ); + } +}; + +/** + * Get a triangle in the terrain in the form of a triangular convex shape. + * @method getConvexTrianglePillar + * @param {integer} i + * @param {integer} j + * @param {boolean} getUpperTriangle + */ +Heightfield.prototype.getConvexTrianglePillar = function(xi, yi, getUpperTriangle){ + var result = this.pillarConvex; + var offsetResult = this.pillarOffset; + + if(this.cacheEnabled){ + var data = this.getCachedConvexTrianglePillar(xi, yi, getUpperTriangle); + if(data){ + this.pillarConvex = data.convex; + this.pillarOffset = data.offset; + return; + } + + result = new ConvexPolyhedron(); + offsetResult = new Vec3(); + + this.pillarConvex = result; + this.pillarOffset = offsetResult; + } + + var data = this.data; + var elementSize = this.elementSize; + var faces = result.faces; + + // Reuse verts if possible + result.vertices.length = 6; + for (var i = 0; i < 6; i++) { + if(!result.vertices[i]){ + result.vertices[i] = new Vec3(); + } + } + + // Reuse faces if possible + faces.length = 5; + for (var i = 0; i < 5; i++) { + if(!faces[i]){ + faces[i] = []; + } + } + + var verts = result.vertices; + + var h = (Math.min( + data[xi][yi], + data[xi+1][yi], + data[xi][yi+1], + data[xi+1][yi+1] + ) - this.minValue ) / 2 + this.minValue; + + if (!getUpperTriangle) { + + // Center of the triangle pillar - all polygons are given relative to this one + offsetResult.set( + (xi + 0.25) * elementSize, // sort of center of a triangle + (yi + 0.25) * elementSize, + h // vertical center + ); + + // Top triangle verts + verts[0].set( + -0.25 * elementSize, + -0.25 * elementSize, + data[xi][yi] - h + ); + verts[1].set( + 0.75 * elementSize, + -0.25 * elementSize, + data[xi + 1][yi] - h + ); + verts[2].set( + -0.25 * elementSize, + 0.75 * elementSize, + data[xi][yi + 1] - h + ); + + // bottom triangle verts + verts[3].set( + -0.25 * elementSize, + -0.25 * elementSize, + -h-1 + ); + verts[4].set( + 0.75 * elementSize, + -0.25 * elementSize, + -h-1 + ); + verts[5].set( + -0.25 * elementSize, + 0.75 * elementSize, + -h-1 + ); + + // top triangle + faces[0][0] = 0; + faces[0][1] = 1; + faces[0][2] = 2; + + // bottom triangle + faces[1][0] = 5; + faces[1][1] = 4; + faces[1][2] = 3; + + // -x facing quad + faces[2][0] = 0; + faces[2][1] = 2; + faces[2][2] = 5; + faces[2][3] = 3; + + // -y facing quad + faces[3][0] = 1; + faces[3][1] = 0; + faces[3][2] = 3; + faces[3][3] = 4; + + // +xy facing quad + faces[4][0] = 4; + faces[4][1] = 5; + faces[4][2] = 2; + faces[4][3] = 1; + + + } else { + + // Center of the triangle pillar - all polygons are given relative to this one + offsetResult.set( + (xi + 0.75) * elementSize, // sort of center of a triangle + (yi + 0.75) * elementSize, + h // vertical center + ); + + // Top triangle verts + verts[0].set( + 0.25 * elementSize, + 0.25 * elementSize, + data[xi + 1][yi + 1] - h + ); + verts[1].set( + -0.75 * elementSize, + 0.25 * elementSize, + data[xi][yi + 1] - h + ); + verts[2].set( + 0.25 * elementSize, + -0.75 * elementSize, + data[xi + 1][yi] - h + ); + + // bottom triangle verts + verts[3].set( + 0.25 * elementSize, + 0.25 * elementSize, + - h-1 + ); + verts[4].set( + -0.75 * elementSize, + 0.25 * elementSize, + - h-1 + ); + verts[5].set( + 0.25 * elementSize, + -0.75 * elementSize, + - h-1 + ); + + // Top triangle + faces[0][0] = 0; + faces[0][1] = 1; + faces[0][2] = 2; + + // bottom triangle + faces[1][0] = 5; + faces[1][1] = 4; + faces[1][2] = 3; + + // +x facing quad + faces[2][0] = 2; + faces[2][1] = 5; + faces[2][2] = 3; + faces[2][3] = 0; + + // +y facing quad + faces[3][0] = 3; + faces[3][1] = 4; + faces[3][2] = 1; + faces[3][3] = 0; + + // -xy facing quad + faces[4][0] = 1; + faces[4][1] = 4; + faces[4][2] = 5; + faces[4][3] = 2; + } + + result.computeNormals(); + result.computeEdges(); + result.updateBoundingSphereRadius(); + + this.setCachedConvexTrianglePillar(xi, yi, getUpperTriangle, result, offsetResult); +}; + +Heightfield.prototype.calculateLocalInertia = function(mass, target){ + target = target || new Vec3(); + target.set(0, 0, 0); + return target; +}; + +Heightfield.prototype.volume = function(){ + return Number.MAX_VALUE; // The terrain is infinite +}; + +Heightfield.prototype.calculateWorldAABB = function(pos, quat, min, max){ + // TODO: do it properly + min.set(-Number.MAX_VALUE, -Number.MAX_VALUE, -Number.MAX_VALUE); + max.set(Number.MAX_VALUE, Number.MAX_VALUE, Number.MAX_VALUE); +}; + +Heightfield.prototype.updateBoundingSphereRadius = function(){ + // Use the bounding box of the min/max values + var data = this.data, + s = this.elementSize; + this.boundingSphereRadius = new Vec3(data.length * s, data[0].length * s, Math.max(Math.abs(this.maxValue), Math.abs(this.minValue))).norm(); +}; + +/** + * Sets the height values from an image. Currently only supported in browser. + * @method setHeightsFromImage + * @param {Image} image + * @param {Vec3} scale + */ +Heightfield.prototype.setHeightsFromImage = function(image, scale){ + var canvas = document.createElement('canvas'); + canvas.width = image.width; + canvas.height = image.height; + var context = canvas.getContext('2d'); + context.drawImage(image, 0, 0); + var imageData = context.getImageData(0, 0, image.width, image.height); + + var matrix = this.data; + matrix.length = 0; + this.elementSize = Math.abs(scale.x) / imageData.width; + for(var i=0; i 0 by subclasses. + * @property type + * @type {Number} + * @see Shape.types + */ + this.type = options.type || 0; + + /** + * The local bounding sphere radius of this shape. + * @property {Number} boundingSphereRadius + */ + this.boundingSphereRadius = 0; + + /** + * Whether to produce contact forces when in contact with other bodies. Note that contacts will be generated, but they will be disabled. + * @property {boolean} collisionResponse + */ + this.collisionResponse = options.collisionResponse ? options.collisionResponse : true; + + /** + * @property {Number} collisionFilterGroup + */ + this.collisionFilterGroup = options.collisionFilterGroup !== undefined ? options.collisionFilterGroup : 1; + + /** + * @property {Number} collisionFilterMask + */ + this.collisionFilterMask = options.collisionFilterMask !== undefined ? options.collisionFilterMask : -1; + + /** + * @property {Material} material + */ + this.material = options.material ? options.material : null; + + /** + * @property {Body} body + */ + this.body = null; +} +Shape.prototype.constructor = Shape; + +/** + * Computes the bounding sphere radius. The result is stored in the property .boundingSphereRadius + * @method updateBoundingSphereRadius + */ +Shape.prototype.updateBoundingSphereRadius = function(){ + throw "computeBoundingSphereRadius() not implemented for shape type "+this.type; +}; + +/** + * Get the volume of this shape + * @method volume + * @return {Number} + */ +Shape.prototype.volume = function(){ + throw "volume() not implemented for shape type "+this.type; +}; + +/** + * Calculates the inertia in the local frame for this shape. + * @method calculateLocalInertia + * @param {Number} mass + * @param {Vec3} target + * @see http://en.wikipedia.org/wiki/List_of_moments_of_inertia + */ +Shape.prototype.calculateLocalInertia = function(mass,target){ + throw "calculateLocalInertia() not implemented for shape type "+this.type; +}; + +Shape.idCounter = 0; + +/** + * The available shape types. + * @static + * @property types + * @type {Object} + */ +Shape.types = { + SPHERE:1, + PLANE:2, + BOX:4, + COMPOUND:8, + CONVEXPOLYHEDRON:16, + HEIGHTFIELD:32, + PARTICLE:64, + CYLINDER:128, + TRIMESH:256 +}; + + +},{"../material/Material":26,"../math/Quaternion":29,"../math/Vec3":31,"./Shape":44}],45:[function(require,module,exports){ +module.exports = Sphere; + +var Shape = require('./Shape'); +var Vec3 = require('../math/Vec3'); + +/** + * Spherical shape + * @class Sphere + * @constructor + * @extends Shape + * @param {Number} radius The radius of the sphere, a non-negative number. + * @author schteppe / http://github.com/schteppe + */ +function Sphere(radius){ + Shape.call(this, { + type: Shape.types.SPHERE + }); + + /** + * @property {Number} radius + */ + this.radius = radius !== undefined ? radius : 1.0; + + if(this.radius < 0){ + throw new Error('The sphere radius cannot be negative.'); + } + + this.updateBoundingSphereRadius(); +} +Sphere.prototype = new Shape(); +Sphere.prototype.constructor = Sphere; + +Sphere.prototype.calculateLocalInertia = function(mass,target){ + target = target || new Vec3(); + var I = 2.0*mass*this.radius*this.radius/5.0; + target.x = I; + target.y = I; + target.z = I; + return target; +}; + +Sphere.prototype.volume = function(){ + return 4.0 * Math.PI * this.radius / 3.0; +}; + +Sphere.prototype.updateBoundingSphereRadius = function(){ + this.boundingSphereRadius = this.radius; +}; + +Sphere.prototype.calculateWorldAABB = function(pos,quat,min,max){ + var r = this.radius; + var axes = ['x','y','z']; + for(var i=0; i u.x){ + u.x = v.x; + } + + if(v.y < l.y){ + l.y = v.y; + } else if(v.y > u.y){ + u.y = v.y; + } + + if(v.z < l.z){ + l.z = v.z; + } else if(v.z > u.z){ + u.z = v.z; + } + } +}; + + +/** + * Update the .aabb property + * @method updateAABB + */ +Trimesh.prototype.updateAABB = function(){ + this.computeLocalAABB(this.aabb); +}; + +/** + * Will update the .boundingSphereRadius property + * @method updateBoundingSphereRadius + */ +Trimesh.prototype.updateBoundingSphereRadius = function(){ + // Assume points are distributed with local (0,0,0) as center + var max2 = 0; + var vertices = this.vertices; + var v = new Vec3(); + for(var i=0, N=vertices.length / 3; i !== N; i++) { + this.getVertex(i, v); + var norm2 = v.norm2(); + if(norm2 > max2){ + max2 = norm2; + } + } + this.boundingSphereRadius = Math.sqrt(max2); +}; + +var tempWorldVertex = new Vec3(); +var calculateWorldAABB_frame = new Transform(); +var calculateWorldAABB_aabb = new AABB(); + +/** + * @method calculateWorldAABB + * @param {Vec3} pos + * @param {Quaternion} quat + * @param {Vec3} min + * @param {Vec3} max + */ +Trimesh.prototype.calculateWorldAABB = function(pos,quat,min,max){ + /* + var n = this.vertices.length / 3, + verts = this.vertices; + var minx,miny,minz,maxx,maxy,maxz; + + var v = tempWorldVertex; + for(var i=0; i maxx || maxx===undefined){ + maxx = v.x; + } + + if (v.y < miny || miny===undefined){ + miny = v.y; + } else if(v.y > maxy || maxy===undefined){ + maxy = v.y; + } + + if (v.z < minz || minz===undefined){ + minz = v.z; + } else if(v.z > maxz || maxz===undefined){ + maxz = v.z; + } + } + min.set(minx,miny,minz); + max.set(maxx,maxy,maxz); + */ + + // Faster approximation using local AABB + var frame = calculateWorldAABB_frame; + var result = calculateWorldAABB_aabb; + frame.position = pos; + frame.quaternion = quat; + this.aabb.toWorldFrame(frame, result); + min.copy(result.lowerBound); + max.copy(result.upperBound); +}; + +/** + * Get approximate volume + * @method volume + * @return {Number} + */ +Trimesh.prototype.volume = function(){ + return 4.0 * Math.PI * this.boundingSphereRadius / 3.0; +}; + +/** + * Create a Trimesh instance, shaped as a torus. + * @static + * @method createTorus + * @param {number} [radius=1] + * @param {number} [tube=0.5] + * @param {number} [radialSegments=8] + * @param {number} [tubularSegments=6] + * @param {number} [arc=6.283185307179586] + * @return {Trimesh} A torus + */ +Trimesh.createTorus = function (radius, tube, radialSegments, tubularSegments, arc) { + radius = radius || 1; + tube = tube || 0.5; + radialSegments = radialSegments || 8; + tubularSegments = tubularSegments || 6; + arc = arc || Math.PI * 2; + + var vertices = []; + var indices = []; + + for ( var j = 0; j <= radialSegments; j ++ ) { + for ( var i = 0; i <= tubularSegments; i ++ ) { + var u = i / tubularSegments * arc; + var v = j / radialSegments * Math.PI * 2; + + var x = ( radius + tube * Math.cos( v ) ) * Math.cos( u ); + var y = ( radius + tube * Math.cos( v ) ) * Math.sin( u ); + var z = tube * Math.sin( v ); + + vertices.push( x, y, z ); + } + } + + for ( var j = 1; j <= radialSegments; j ++ ) { + for ( var i = 1; i <= tubularSegments; i ++ ) { + var a = ( tubularSegments + 1 ) * j + i - 1; + var b = ( tubularSegments + 1 ) * ( j - 1 ) + i - 1; + var c = ( tubularSegments + 1 ) * ( j - 1 ) + i; + var d = ( tubularSegments + 1 ) * j + i; + + indices.push(a, b, d); + indices.push(b, c, d); + } + } + + return new Trimesh(vertices, indices); +}; + +},{"../collision/AABB":3,"../math/Quaternion":29,"../math/Transform":30,"../math/Vec3":31,"../utils/Octree":51,"./Shape":44}],47:[function(require,module,exports){ +module.exports = GSSolver; + +var Vec3 = require('../math/Vec3'); +var Quaternion = require('../math/Quaternion'); +var Solver = require('./Solver'); + +/** + * Constraint equation Gauss-Seidel solver. + * @class GSSolver + * @constructor + * @todo The spook parameters should be specified for each constraint, not globally. + * @author schteppe / https://github.com/schteppe + * @see https://www8.cs.umu.se/kurser/5DV058/VT09/lectures/spooknotes.pdf + * @extends Solver + */ +function GSSolver(){ + Solver.call(this); + + /** + * The number of solver iterations determines quality of the constraints in the world. The more iterations, the more correct simulation. More iterations need more computations though. If you have a large gravity force in your world, you will need more iterations. + * @property iterations + * @type {Number} + * @todo write more about solver and iterations in the wiki + */ + this.iterations = 10; + + /** + * When tolerance is reached, the system is assumed to be converged. + * @property tolerance + * @type {Number} + */ + this.tolerance = 1e-7; +} +GSSolver.prototype = new Solver(); + +var GSSolver_solve_lambda = []; // Just temporary number holders that we want to reuse each solve. +var GSSolver_solve_invCs = []; +var GSSolver_solve_Bs = []; +GSSolver.prototype.solve = function(dt,world){ + var iter = 0, + maxIter = this.iterations, + tolSquared = this.tolerance*this.tolerance, + equations = this.equations, + Neq = equations.length, + bodies = world.bodies, + Nbodies = bodies.length, + h = dt, + q, B, invC, deltalambda, deltalambdaTot, GWlambda, lambdaj; + + // Update solve mass + if(Neq !== 0){ + for(var i=0; i!==Nbodies; i++){ + bodies[i].updateSolveMassProperties(); + } + } + + // Things that does not change during iteration can be computed once + var invCs = GSSolver_solve_invCs, + Bs = GSSolver_solve_Bs, + lambda = GSSolver_solve_lambda; + invCs.length = Neq; + Bs.length = Neq; + lambda.length = Neq; + for(var i=0; i!==Neq; i++){ + var c = equations[i]; + lambda[i] = 0.0; + Bs[i] = c.computeB(h); + invCs[i] = 1.0 / c.computeC(); + } + + if(Neq !== 0){ + + // Reset vlambda + for(var i=0; i!==Nbodies; i++){ + var b=bodies[i], + vlambda=b.vlambda, + wlambda=b.wlambda; + vlambda.set(0,0,0); + wlambda.set(0,0,0); + } + + // Iterate over equations + for(iter=0; iter!==maxIter; iter++){ + + // Accumulate the total error for each iteration. + deltalambdaTot = 0.0; + + for(var j=0; j!==Neq; j++){ + + var c = equations[j]; + + // Compute iteration + B = Bs[j]; + invC = invCs[j]; + lambdaj = lambda[j]; + GWlambda = c.computeGWlambda(); + deltalambda = invC * ( B - GWlambda - c.eps * lambdaj ); + + // Clamp if we are not within the min/max interval + if(lambdaj + deltalambda < c.minForce){ + deltalambda = c.minForce - lambdaj; + } else if(lambdaj + deltalambda > c.maxForce){ + deltalambda = c.maxForce - lambdaj; + } + lambda[j] += deltalambda; + + deltalambdaTot += deltalambda > 0.0 ? deltalambda : -deltalambda; // abs(deltalambda) + + c.addToWlambda(deltalambda); + } + + // If the total error is small enough - stop iterate + if(deltalambdaTot*deltalambdaTot < tolSquared){ + break; + } + } + + // Add result to velocity + for(var i=0; i!==Nbodies; i++){ + var b=bodies[i], + v=b.velocity, + w=b.angularVelocity; + + b.vlambda.vmul(b.linearFactor, b.vlambda); + v.vadd(b.vlambda, v); + + b.wlambda.vmul(b.angularFactor, b.wlambda); + w.vadd(b.wlambda, w); + } + + // Set the .multiplier property of each equation + var l = equations.length; + var invDt = 1 / h; + while(l--){ + equations[l].multiplier = lambda[l] * invDt; + } + } + + return iter; +}; + +},{"../math/Quaternion":29,"../math/Vec3":31,"./Solver":48}],48:[function(require,module,exports){ +module.exports = Solver; + +/** + * Constraint equation solver base class. + * @class Solver + * @constructor + * @author schteppe / https://github.com/schteppe + */ +function Solver(){ + /** + * All equations to be solved + * @property {Array} equations + */ + this.equations = []; +} + +/** + * Should be implemented in subclasses! + * @method solve + * @param {Number} dt + * @param {World} world + */ +Solver.prototype.solve = function(dt,world){ + // Should return the number of iterations done! + return 0; +}; + +/** + * Add an equation + * @method addEquation + * @param {Equation} eq + */ +Solver.prototype.addEquation = function(eq){ + if (eq.enabled) { + this.equations.push(eq); + } +}; + +/** + * Remove an equation + * @method removeEquation + * @param {Equation} eq + */ +Solver.prototype.removeEquation = function(eq){ + var eqs = this.equations; + var i = eqs.indexOf(eq); + if(i !== -1){ + eqs.splice(i,1); + } +}; + +/** + * Add all equations + * @method removeAllEquations + */ +Solver.prototype.removeAllEquations = function(){ + this.equations.length = 0; +}; + + +},{}],49:[function(require,module,exports){ +module.exports = SplitSolver; + +var Vec3 = require('../math/Vec3'); +var Quaternion = require('../math/Quaternion'); +var Solver = require('./Solver'); +var Body = require('../objects/Body'); + +/** + * Splits the equations into islands and solves them independently. Can improve performance. + * @class SplitSolver + * @constructor + * @extends Solver + * @param {Solver} subsolver + */ +function SplitSolver(subsolver){ + Solver.call(this); + this.iterations = 10; + this.tolerance = 1e-7; + this.subsolver = subsolver; + this.nodes = []; + this.nodePool = []; + + // Create needed nodes, reuse if possible + while(this.nodePool.length < 128){ + this.nodePool.push(this.createNode()); + } +} +SplitSolver.prototype = new Solver(); + +// Returns the number of subsystems +var SplitSolver_solve_nodes = []; // All allocated node objects +var SplitSolver_solve_nodePool = []; // All allocated node objects +var SplitSolver_solve_eqs = []; // Temp array +var SplitSolver_solve_bds = []; // Temp array +var SplitSolver_solve_dummyWorld = {bodies:[]}; // Temp object + +var STATIC = Body.STATIC; +function getUnvisitedNode(nodes){ + var Nnodes = nodes.length; + for(var i=0; i!==Nnodes; i++){ + var node = nodes[i]; + if(!node.visited && !(node.body.type & STATIC)){ + return node; + } + } + return false; +} + +var queue = []; +function bfs(root,visitFunc,bds,eqs){ + queue.push(root); + root.visited = true; + visitFunc(root,bds,eqs); + while(queue.length) { + var node = queue.pop(); + // Loop over unvisited child nodes + var child; + while((child = getUnvisitedNode(node.children))) { + child.visited = true; + visitFunc(child,bds,eqs); + queue.push(child); + } + } +} + +function visitFunc(node,bds,eqs){ + bds.push(node.body); + var Neqs = node.eqs.length; + for(var i=0; i!==Neqs; i++){ + var eq = node.eqs[i]; + if(eqs.indexOf(eq) === -1){ + eqs.push(eq); + } + } +} + +SplitSolver.prototype.createNode = function(){ + return { body:null, children:[], eqs:[], visited:false }; +}; + +/** + * Solve the subsystems + * @method solve + * @param {Number} dt + * @param {World} world + */ +SplitSolver.prototype.solve = function(dt,world){ + var nodes=SplitSolver_solve_nodes, + nodePool=this.nodePool, + bodies=world.bodies, + equations=this.equations, + Neq=equations.length, + Nbodies=bodies.length, + subsolver=this.subsolver; + + // Create needed nodes, reuse if possible + while(nodePool.length < Nbodies){ + nodePool.push(this.createNode()); + } + nodes.length = Nbodies; + for (var i = 0; i < Nbodies; i++) { + nodes[i] = nodePool[i]; + } + + // Reset node values + for(var i=0; i!==Nbodies; i++){ + var node = nodes[i]; + node.body = bodies[i]; + node.children.length = 0; + node.eqs.length = 0; + node.visited = false; + } + for(var k=0; k!==Neq; k++){ + var eq=equations[k], + i=bodies.indexOf(eq.bi), + j=bodies.indexOf(eq.bj), + ni=nodes[i], + nj=nodes[j]; + ni.children.push(nj); + ni.eqs.push(eq); + nj.children.push(ni); + nj.eqs.push(eq); + } + + var child, n=0, eqs=SplitSolver_solve_eqs; + + subsolver.tolerance = this.tolerance; + subsolver.iterations = this.iterations; + + var dummyWorld = SplitSolver_solve_dummyWorld; + while((child = getUnvisitedNode(nodes))){ + eqs.length = 0; + dummyWorld.bodies.length = 0; + bfs(child, visitFunc, dummyWorld.bodies, eqs); + + var Neqs = eqs.length; + + eqs = eqs.sort(sortById); + + for(var i=0; i!==Neqs; i++){ + subsolver.addEquation(eqs[i]); + } + + var iter = subsolver.solve(dt,dummyWorld); + subsolver.removeAllEquations(); + n++; + } + + return n; +}; + +function sortById(a, b){ + return b.id - a.id; +} +},{"../math/Quaternion":29,"../math/Vec3":31,"../objects/Body":32,"./Solver":48}],50:[function(require,module,exports){ +/** + * Base class for objects that dispatches events. + * @class EventTarget + * @constructor + */ +var EventTarget = function () { + +}; + +module.exports = EventTarget; + +EventTarget.prototype = { + constructor: EventTarget, + + /** + * Add an event listener + * @method addEventListener + * @param {String} type + * @param {Function} listener + * @return {EventTarget} The self object, for chainability. + */ + addEventListener: function ( type, listener ) { + if ( this._listeners === undefined ){ this._listeners = {}; } + var listeners = this._listeners; + if ( listeners[ type ] === undefined ) { + listeners[ type ] = []; + } + if ( listeners[ type ].indexOf( listener ) === - 1 ) { + listeners[ type ].push( listener ); + } + return this; + }, + + /** + * Check if an event listener is added + * @method hasEventListener + * @param {String} type + * @param {Function} listener + * @return {Boolean} + */ + hasEventListener: function ( type, listener ) { + if ( this._listeners === undefined ){ return false; } + var listeners = this._listeners; + if ( listeners[ type ] !== undefined && listeners[ type ].indexOf( listener ) !== - 1 ) { + return true; + } + return false; + }, + + /** + * Check if any event listener of the given type is added + * @method hasAnyEventListener + * @param {String} type + * @return {Boolean} + */ + hasAnyEventListener: function ( type ) { + if ( this._listeners === undefined ){ return false; } + var listeners = this._listeners; + return ( listeners[ type ] !== undefined ); + }, + + /** + * Remove an event listener + * @method removeEventListener + * @param {String} type + * @param {Function} listener + * @return {EventTarget} The self object, for chainability. + */ + removeEventListener: function ( type, listener ) { + if ( this._listeners === undefined ){ return this; } + var listeners = this._listeners; + if ( listeners[type] === undefined ){ return this; } + var index = listeners[ type ].indexOf( listener ); + if ( index !== - 1 ) { + listeners[ type ].splice( index, 1 ); + } + return this; + }, + + /** + * Emit an event. + * @method dispatchEvent + * @param {Object} event + * @param {String} event.type + * @return {EventTarget} The self object, for chainability. + */ + dispatchEvent: function ( event ) { + if ( this._listeners === undefined ){ return this; } + var listeners = this._listeners; + var listenerArray = listeners[ event.type ]; + if ( listenerArray !== undefined ) { + event.target = this; + for ( var i = 0, l = listenerArray.length; i < l; i ++ ) { + listenerArray[ i ].call( this, event ); + } + } + return this; + } +}; + +},{}],51:[function(require,module,exports){ +var AABB = require('../collision/AABB'); +var Vec3 = require('../math/Vec3'); + +module.exports = Octree; + +/** + * @class OctreeNode + * @param {object} [options] + * @param {Octree} [options.root] + * @param {AABB} [options.aabb] + */ +function OctreeNode(options){ + options = options || {}; + + /** + * The root node + * @property {OctreeNode} root + */ + this.root = options.root || null; + + /** + * Boundary of this node + * @property {AABB} aabb + */ + this.aabb = options.aabb ? options.aabb.clone() : new AABB(); + + /** + * Contained data at the current node level. + * @property {Array} data + */ + this.data = []; + + /** + * Children to this node + * @property {Array} children + */ + this.children = []; +} + +/** + * @class Octree + * @param {AABB} aabb The total AABB of the tree + * @param {object} [options] + * @param {number} [options.maxDepth=8] + * @extends OctreeNode + */ +function Octree(aabb, options){ + options = options || {}; + options.root = null; + options.aabb = aabb; + OctreeNode.call(this, options); + + /** + * Maximum subdivision depth + * @property {number} maxDepth + */ + this.maxDepth = typeof(options.maxDepth) !== 'undefined' ? options.maxDepth : 8; +} +Octree.prototype = new OctreeNode(); + +OctreeNode.prototype.reset = function(aabb, options){ + this.children.length = this.data.length = 0; +}; + +/** + * Insert data into this node + * @method insert + * @param {AABB} aabb + * @param {object} elementData + * @return {boolean} True if successful, otherwise false + */ +OctreeNode.prototype.insert = function(aabb, elementData, level){ + var nodeData = this.data; + level = level || 0; + + // Ignore objects that do not belong in this node + if (!this.aabb.contains(aabb)){ + return false; // object cannot be added + } + + var children = this.children; + + if(level < (this.maxDepth || this.root.maxDepth)){ + // Subdivide if there are no children yet + var subdivided = false; + if (!children.length){ + this.subdivide(); + subdivided = true; + } + + // add to whichever node will accept it + for (var i = 0; i !== 8; i++) { + if (children[i].insert(aabb, elementData, level + 1)){ + return true; + } + } + + if(subdivided){ + // No children accepted! Might as well just remove em since they contain none + children.length = 0; + } + } + + // Too deep, or children didnt want it. add it in current node + nodeData.push(elementData); + + return true; +}; + +var halfDiagonal = new Vec3(); + +/** + * Create 8 equally sized children nodes and put them in the .children array. + * @method subdivide + */ +OctreeNode.prototype.subdivide = function() { + var aabb = this.aabb; + var l = aabb.lowerBound; + var u = aabb.upperBound; + + var children = this.children; + + children.push( + new OctreeNode({ aabb: new AABB({ lowerBound: new Vec3(0,0,0) }) }), + new OctreeNode({ aabb: new AABB({ lowerBound: new Vec3(1,0,0) }) }), + new OctreeNode({ aabb: new AABB({ lowerBound: new Vec3(1,1,0) }) }), + new OctreeNode({ aabb: new AABB({ lowerBound: new Vec3(1,1,1) }) }), + new OctreeNode({ aabb: new AABB({ lowerBound: new Vec3(0,1,1) }) }), + new OctreeNode({ aabb: new AABB({ lowerBound: new Vec3(0,0,1) }) }), + new OctreeNode({ aabb: new AABB({ lowerBound: new Vec3(1,0,1) }) }), + new OctreeNode({ aabb: new AABB({ lowerBound: new Vec3(0,1,0) }) }) + ); + + u.vsub(l, halfDiagonal); + halfDiagonal.scale(0.5, halfDiagonal); + + var root = this.root || this; + + for (var i = 0; i !== 8; i++) { + var child = children[i]; + + // Set current node as root + child.root = root; + + // Compute bounds + var lowerBound = child.aabb.lowerBound; + lowerBound.x *= halfDiagonal.x; + lowerBound.y *= halfDiagonal.y; + lowerBound.z *= halfDiagonal.z; + + lowerBound.vadd(l, lowerBound); + + // Upper bound is always lower bound + halfDiagonal + lowerBound.vadd(halfDiagonal, child.aabb.upperBound); + } +}; + +/** + * Get all data, potentially within an AABB + * @method aabbQuery + * @param {AABB} aabb + * @param {array} result + * @return {array} The "result" object + */ +OctreeNode.prototype.aabbQuery = function(aabb, result) { + + var nodeData = this.data; + + // abort if the range does not intersect this node + // if (!this.aabb.overlaps(aabb)){ + // return result; + // } + + // Add objects at this level + // Array.prototype.push.apply(result, nodeData); + + // Add child data + // @todo unwrap recursion into a queue / loop, that's faster in JS + var children = this.children; + + + // for (var i = 0, N = this.children.length; i !== N; i++) { + // children[i].aabbQuery(aabb, result); + // } + + var queue = [this]; + while (queue.length) { + var node = queue.pop(); + if (node.aabb.overlaps(aabb)){ + Array.prototype.push.apply(result, node.data); + } + Array.prototype.push.apply(queue, node.children); + } + + return result; +}; + +var tmpAABB = new AABB(); + +/** + * Get all data, potentially intersected by a ray. + * @method rayQuery + * @param {Ray} ray + * @param {Transform} treeTransform + * @param {array} result + * @return {array} The "result" object + */ +OctreeNode.prototype.rayQuery = function(ray, treeTransform, result) { + + // Use aabb query for now. + // @todo implement real ray query which needs less lookups + ray.getAABB(tmpAABB); + tmpAABB.toLocalFrame(treeTransform, tmpAABB); + this.aabbQuery(tmpAABB, result); + + return result; +}; + +/** + * @method removeEmptyNodes + */ +OctreeNode.prototype.removeEmptyNodes = function() { + var queue = [this]; + while (queue.length) { + var node = queue.pop(); + for (var i = node.children.length - 1; i >= 0; i--) { + if(!node.children[i].data.length){ + node.children.splice(i, 1); + } + } + Array.prototype.push.apply(queue, node.children); + } +}; + +},{"../collision/AABB":3,"../math/Vec3":31}],52:[function(require,module,exports){ +module.exports = Pool; + +/** + * For pooling objects that can be reused. + * @class Pool + * @constructor + */ +function Pool(){ + /** + * The pooled objects + * @property {Array} objects + */ + this.objects = []; + + /** + * Constructor of the objects + * @property {mixed} type + */ + this.type = Object; +} + +/** + * Release an object after use + * @method release + * @param {Object} obj + */ +Pool.prototype.release = function(){ + var Nargs = arguments.length; + for(var i=0; i!==Nargs; i++){ + this.objects.push(arguments[i]); + } + return this; +}; + +/** + * Get an object + * @method get + * @return {mixed} + */ +Pool.prototype.get = function(){ + if(this.objects.length===0){ + return this.constructObject(); + } else { + return this.objects.pop(); + } +}; + +/** + * Construct an object. Should be implmented in each subclass. + * @method constructObject + * @return {mixed} + */ +Pool.prototype.constructObject = function(){ + throw new Error("constructObject() not implemented in this Pool subclass yet!"); +}; + +/** + * @method resize + * @param {number} size + * @return {Pool} Self, for chaining + */ +Pool.prototype.resize = function (size) { + var objects = this.objects; + + while (objects.length > size) { + objects.pop(); + } + + while (objects.length < size) { + objects.push(this.constructObject()); + } + + return this; +}; + + +},{}],53:[function(require,module,exports){ +module.exports = TupleDictionary; + +/** + * @class TupleDictionary + * @constructor + */ +function TupleDictionary() { + + /** + * The data storage + * @property data + * @type {Object} + */ + this.data = { keys:[] }; +} + +/** + * @method get + * @param {Number} i + * @param {Number} j + * @return {Number} + */ +TupleDictionary.prototype.get = function(i, j) { + if (i > j) { + // swap + var temp = j; + j = i; + i = temp; + } + return this.data[i+'-'+j]; +}; + +/** + * @method set + * @param {Number} i + * @param {Number} j + * @param {Number} value + */ +TupleDictionary.prototype.set = function(i, j, value) { + if (i > j) { + var temp = j; + j = i; + i = temp; + } + var key = i+'-'+j; + + // Check if key already exists + if(!this.get(i,j)){ + this.data.keys.push(key); + } + + this.data[key] = value; +}; + +/** + * @method reset + */ +TupleDictionary.prototype.reset = function() { + var data = this.data, + keys = data.keys; + while(keys.length > 0){ + var key = keys.pop(); + delete data[key]; + } +}; + +},{}],54:[function(require,module,exports){ +function Utils(){} + +module.exports = Utils; + +/** + * Extend an options object with default values. + * @static + * @method defaults + * @param {object} options The options object. May be falsy: in this case, a new object is created and returned. + * @param {object} defaults An object containing default values. + * @return {object} The modified options object. + */ +Utils.defaults = function(options, defaults){ + options = options || {}; + + for(var key in defaults){ + if(!(key in options)){ + options[key] = defaults[key]; + } + } + + return options; +}; + +},{}],55:[function(require,module,exports){ +module.exports = Vec3Pool; + +var Vec3 = require('../math/Vec3'); +var Pool = require('./Pool'); + +/** + * @class Vec3Pool + * @constructor + * @extends Pool + */ +function Vec3Pool(){ + Pool.call(this); + this.type = Vec3; +} +Vec3Pool.prototype = new Pool(); + +/** + * Construct a vector + * @method constructObject + * @return {Vec3} + */ +Vec3Pool.prototype.constructObject = function(){ + return new Vec3(); +}; + +},{"../math/Vec3":31,"./Pool":52}],56:[function(require,module,exports){ +module.exports = Narrowphase; + +var AABB = require('../collision/AABB'); +var Body = require('../objects/Body'); +var Shape = require('../shapes/Shape'); +var Ray = require('../collision/Ray'); +var Vec3 = require('../math/Vec3'); +var Transform = require('../math/Transform'); +var ConvexPolyhedron = require('../shapes/ConvexPolyhedron'); +var Quaternion = require('../math/Quaternion'); +var Solver = require('../solver/Solver'); +var Vec3Pool = require('../utils/Vec3Pool'); +var ContactEquation = require('../equations/ContactEquation'); +var FrictionEquation = require('../equations/FrictionEquation'); + +/** + * Helper class for the World. Generates ContactEquations. + * @class Narrowphase + * @constructor + * @todo Sphere-ConvexPolyhedron contacts + * @todo Contact reduction + * @todo should move methods to prototype + */ +function Narrowphase(world){ + + /** + * Internal storage of pooled contact points. + * @property {Array} contactPointPool + */ + this.contactPointPool = []; + + this.frictionEquationPool = []; + + this.result = []; + this.frictionResult = []; + + /** + * Pooled vectors. + * @property {Vec3Pool} v3pool + */ + this.v3pool = new Vec3Pool(); + + this.world = world; + this.currentContactMaterial = null; + + /** + * @property {Boolean} enableFrictionReduction + */ + this.enableFrictionReduction = false; +} + +/** + * Make a contact object, by using the internal pool or creating a new one. + * @method createContactEquation + * @param {Body} bi + * @param {Body} bj + * @param {Shape} si + * @param {Shape} sj + * @param {Shape} overrideShapeA + * @param {Shape} overrideShapeB + * @return {ContactEquation} + */ +Narrowphase.prototype.createContactEquation = function(bi, bj, si, sj, overrideShapeA, overrideShapeB){ + var c; + if(this.contactPointPool.length){ + c = this.contactPointPool.pop(); + c.bi = bi; + c.bj = bj; + } else { + c = new ContactEquation(bi, bj); + } + + c.enabled = bi.collisionResponse && bj.collisionResponse && si.collisionResponse && sj.collisionResponse; + + var cm = this.currentContactMaterial; + + c.restitution = cm.restitution; + + c.setSpookParams( + cm.contactEquationStiffness, + cm.contactEquationRelaxation, + this.world.dt + ); + + var matA = si.material || bi.material; + var matB = sj.material || bj.material; + if(matA && matB && matA.restitution >= 0 && matB.restitution >= 0){ + c.restitution = matA.restitution * matB.restitution; + } + + c.si = overrideShapeA || si; + c.sj = overrideShapeB || sj; + + return c; +}; + +Narrowphase.prototype.createFrictionEquationsFromContact = function(contactEquation, outArray){ + var bodyA = contactEquation.bi; + var bodyB = contactEquation.bj; + var shapeA = contactEquation.si; + var shapeB = contactEquation.sj; + + var world = this.world; + var cm = this.currentContactMaterial; + + // If friction or restitution were specified in the material, use them + var friction = cm.friction; + var matA = shapeA.material || bodyA.material; + var matB = shapeB.material || bodyB.material; + if(matA && matB && matA.friction >= 0 && matB.friction >= 0){ + friction = matA.friction * matB.friction; + } + + if(friction > 0){ + + // Create 2 tangent equations + var mug = friction * world.gravity.length(); + var reducedMass = (bodyA.invMass + bodyB.invMass); + if(reducedMass > 0){ + reducedMass = 1/reducedMass; + } + var pool = this.frictionEquationPool; + var c1 = pool.length ? pool.pop() : new FrictionEquation(bodyA,bodyB,mug*reducedMass); + var c2 = pool.length ? pool.pop() : new FrictionEquation(bodyA,bodyB,mug*reducedMass); + + c1.bi = c2.bi = bodyA; + c1.bj = c2.bj = bodyB; + c1.minForce = c2.minForce = -mug*reducedMass; + c1.maxForce = c2.maxForce = mug*reducedMass; + + // Copy over the relative vectors + c1.ri.copy(contactEquation.ri); + c1.rj.copy(contactEquation.rj); + c2.ri.copy(contactEquation.ri); + c2.rj.copy(contactEquation.rj); + + // Construct tangents + contactEquation.ni.tangents(c1.t, c2.t); + + // Set spook params + c1.setSpookParams(cm.frictionEquationStiffness, cm.frictionEquationRelaxation, world.dt); + c2.setSpookParams(cm.frictionEquationStiffness, cm.frictionEquationRelaxation, world.dt); + + c1.enabled = c2.enabled = contactEquation.enabled; + + outArray.push(c1, c2); + + return true; + } + + return false; +}; + +var averageNormal = new Vec3(); +var averageContactPointA = new Vec3(); +var averageContactPointB = new Vec3(); + +// Take the average N latest contact point on the plane. +Narrowphase.prototype.createFrictionFromAverage = function(numContacts){ + // The last contactEquation + var c = this.result[this.result.length - 1]; + + // Create the result: two "average" friction equations + if (!this.createFrictionEquationsFromContact(c, this.frictionResult) || numContacts === 1) { + return; + } + + var f1 = this.frictionResult[this.frictionResult.length - 2]; + var f2 = this.frictionResult[this.frictionResult.length - 1]; + + averageNormal.setZero(); + averageContactPointA.setZero(); + averageContactPointB.setZero(); + + var bodyA = c.bi; + var bodyB = c.bj; + for(var i=0; i!==numContacts; i++){ + c = this.result[this.result.length - 1 - i]; + if(c.bodyA !== bodyA){ + averageNormal.vadd(c.ni, averageNormal); + averageContactPointA.vadd(c.ri, averageContactPointA); + averageContactPointB.vadd(c.rj, averageContactPointB); + } else { + averageNormal.vsub(c.ni, averageNormal); + averageContactPointA.vadd(c.rj, averageContactPointA); + averageContactPointB.vadd(c.ri, averageContactPointB); + } + } + + var invNumContacts = 1 / numContacts; + averageContactPointA.scale(invNumContacts, f1.ri); + averageContactPointB.scale(invNumContacts, f1.rj); + f2.ri.copy(f1.ri); // Should be the same + f2.rj.copy(f1.rj); + averageNormal.normalize(); + averageNormal.tangents(f1.t, f2.t); + // return eq; +}; + + +var tmpVec1 = new Vec3(); +var tmpVec2 = new Vec3(); +var tmpQuat1 = new Quaternion(); +var tmpQuat2 = new Quaternion(); + +/** + * Generate all contacts between a list of body pairs + * @method getContacts + * @param {array} p1 Array of body indices + * @param {array} p2 Array of body indices + * @param {World} world + * @param {array} result Array to store generated contacts + * @param {array} oldcontacts Optional. Array of reusable contact objects + */ +Narrowphase.prototype.getContacts = function(p1, p2, world, result, oldcontacts, frictionResult, frictionPool){ + // Save old contact objects + this.contactPointPool = oldcontacts; + this.frictionEquationPool = frictionPool; + this.result = result; + this.frictionResult = frictionResult; + + var qi = tmpQuat1; + var qj = tmpQuat2; + var xi = tmpVec1; + var xj = tmpVec2; + + for(var k=0, N=p1.length; k!==N; k++){ + + // Get current collision bodies + var bi = p1[k], + bj = p2[k]; + + // Get contact material + var bodyContactMaterial = null; + if(bi.material && bj.material){ + bodyContactMaterial = world.getContactMaterial(bi.material,bj.material) || null; + } + + var justTest = ( + ( + (bi.type & Body.KINEMATIC) && (bj.type & Body.STATIC) + ) || ( + (bi.type & Body.STATIC) && (bj.type & Body.KINEMATIC) + ) || ( + (bi.type & Body.KINEMATIC) && (bj.type & Body.KINEMATIC) + ) + ); + + for (var i = 0; i < bi.shapes.length; i++) { + bi.quaternion.mult(bi.shapeOrientations[i], qi); + bi.quaternion.vmult(bi.shapeOffsets[i], xi); + xi.vadd(bi.position, xi); + var si = bi.shapes[i]; + + for (var j = 0; j < bj.shapes.length; j++) { + + // Compute world transform of shapes + bj.quaternion.mult(bj.shapeOrientations[j], qj); + bj.quaternion.vmult(bj.shapeOffsets[j], xj); + xj.vadd(bj.position, xj); + var sj = bj.shapes[j]; + + if(!((si.collisionFilterMask & sj.collisionFilterGroup) && (sj.collisionFilterMask & si.collisionFilterGroup))){ + continue; + } + + if(xi.distanceTo(xj) > si.boundingSphereRadius + sj.boundingSphereRadius){ + continue; + } + + // Get collision material + var shapeContactMaterial = null; + if(si.material && sj.material){ + shapeContactMaterial = world.getContactMaterial(si.material,sj.material) || null; + } + + this.currentContactMaterial = shapeContactMaterial || bodyContactMaterial || world.defaultContactMaterial; + + // Get contacts + var resolver = this[si.type | sj.type]; + if(resolver){ + var retval = false; + if (si.type < sj.type) { + retval = resolver.call(this, si, sj, xi, xj, qi, qj, bi, bj, si, sj, justTest); + } else { + retval = resolver.call(this, sj, si, xj, xi, qj, qi, bj, bi, si, sj, justTest); + } + + if(retval && justTest){ + // Register overlap + world.shapeOverlapKeeper.set(si.id, sj.id); + world.bodyOverlapKeeper.set(bi.id, bj.id); + } + } + } + } + } +}; + +var numWarnings = 0; +var maxWarnings = 10; + +function warn(msg){ + if(numWarnings > maxWarnings){ + return; + } + + numWarnings++; + + console.warn(msg); +} + +Narrowphase.prototype[Shape.types.BOX | Shape.types.BOX] = +Narrowphase.prototype.boxBox = function(si,sj,xi,xj,qi,qj,bi,bj,rsi,rsj,justTest){ + si.convexPolyhedronRepresentation.material = si.material; + sj.convexPolyhedronRepresentation.material = sj.material; + si.convexPolyhedronRepresentation.collisionResponse = si.collisionResponse; + sj.convexPolyhedronRepresentation.collisionResponse = sj.collisionResponse; + return this.convexConvex(si.convexPolyhedronRepresentation,sj.convexPolyhedronRepresentation,xi,xj,qi,qj,bi,bj,si,sj,justTest); +}; + +Narrowphase.prototype[Shape.types.BOX | Shape.types.CONVEXPOLYHEDRON] = +Narrowphase.prototype.boxConvex = function(si,sj,xi,xj,qi,qj,bi,bj,rsi,rsj,justTest){ + si.convexPolyhedronRepresentation.material = si.material; + si.convexPolyhedronRepresentation.collisionResponse = si.collisionResponse; + return this.convexConvex(si.convexPolyhedronRepresentation,sj,xi,xj,qi,qj,bi,bj,si,sj,justTest); +}; + +Narrowphase.prototype[Shape.types.BOX | Shape.types.PARTICLE] = +Narrowphase.prototype.boxParticle = function(si,sj,xi,xj,qi,qj,bi,bj,rsi,rsj,justTest){ + si.convexPolyhedronRepresentation.material = si.material; + si.convexPolyhedronRepresentation.collisionResponse = si.collisionResponse; + return this.convexParticle(si.convexPolyhedronRepresentation,sj,xi,xj,qi,qj,bi,bj,si,sj,justTest); +}; + +/** + * @method sphereSphere + * @param {Shape} si + * @param {Shape} sj + * @param {Vec3} xi + * @param {Vec3} xj + * @param {Quaternion} qi + * @param {Quaternion} qj + * @param {Body} bi + * @param {Body} bj + */ +Narrowphase.prototype[Shape.types.SPHERE] = +Narrowphase.prototype.sphereSphere = function(si,sj,xi,xj,qi,qj,bi,bj,rsi,rsj,justTest){ + if(justTest){ + return xi.distanceSquared(xj) < Math.pow(si.radius + sj.radius, 2); + } + + // We will have only one contact in this case + var r = this.createContactEquation(bi,bj,si,sj,rsi,rsj); + + // Contact normal + xj.vsub(xi, r.ni); + r.ni.normalize(); + + // Contact point locations + r.ri.copy(r.ni); + r.rj.copy(r.ni); + r.ri.mult(si.radius, r.ri); + r.rj.mult(-sj.radius, r.rj); + + r.ri.vadd(xi, r.ri); + r.ri.vsub(bi.position, r.ri); + + r.rj.vadd(xj, r.rj); + r.rj.vsub(bj.position, r.rj); + + this.result.push(r); + + this.createFrictionEquationsFromContact(r, this.frictionResult); +}; + +/** + * @method planeTrimesh + * @param {Shape} si + * @param {Shape} sj + * @param {Vec3} xi + * @param {Vec3} xj + * @param {Quaternion} qi + * @param {Quaternion} qj + * @param {Body} bi + * @param {Body} bj + */ +var planeTrimesh_normal = new Vec3(); +var planeTrimesh_relpos = new Vec3(); +var planeTrimesh_projected = new Vec3(); +Narrowphase.prototype[Shape.types.PLANE | Shape.types.TRIMESH] = +Narrowphase.prototype.planeTrimesh = function( + planeShape, + trimeshShape, + planePos, + trimeshPos, + planeQuat, + trimeshQuat, + planeBody, + trimeshBody, + rsi, + rsj, + justTest +){ + // Make contacts! + var v = new Vec3(); + + var normal = planeTrimesh_normal; + normal.set(0,0,1); + planeQuat.vmult(normal,normal); // Turn normal according to plane + + for(var i=0; i 0 && positionAlongEdgeB < 0){ + + // Now check the orthogonal distance from edge to sphere center + localSpherePos.vsub(edgeVertexA, tmp); + + edgeVectorUnit.copy(edgeVector); + edgeVectorUnit.normalize(); + positionAlongEdgeA = tmp.dot(edgeVectorUnit); + + edgeVectorUnit.scale(positionAlongEdgeA, tmp); + tmp.vadd(edgeVertexA, tmp); + + // tmp is now the sphere center position projected to the edge, defined locally in the trimesh frame + var dist = tmp.distanceTo(localSpherePos); + if(dist < sphereShape.radius){ + + if(justTest){ + return true; + } + + var r = this.createContactEquation(sphereBody, trimeshBody, sphereShape, trimeshShape,rsi,rsj); + + tmp.vsub(localSpherePos, r.ni); + r.ni.normalize(); + r.ni.scale(sphereShape.radius, r.ri); + + Transform.pointToWorldFrame(trimeshPos, trimeshQuat, tmp, tmp); + tmp.vsub(trimeshBody.position, r.rj); + + Transform.vectorToWorldFrame(trimeshQuat, r.ni, r.ni); + Transform.vectorToWorldFrame(trimeshQuat, r.ri, r.ri); + + this.result.push(r); + this.createFrictionEquationsFromContact(r, this.frictionResult); + } + } + } + } + + // Triangle faces + var va = sphereTrimesh_va; + var vb = sphereTrimesh_vb; + var vc = sphereTrimesh_vc; + var normal = sphereTrimesh_normal; + for(var i=0, N = triangles.length; i !== N; i++){ + trimeshShape.getTriangleVertices(triangles[i], va, vb, vc); + trimeshShape.getNormal(triangles[i], normal); + localSpherePos.vsub(va, tmp); + var dist = tmp.dot(normal); + normal.scale(dist, tmp); + localSpherePos.vsub(tmp, tmp); + + // tmp is now the sphere position projected to the triangle plane + dist = tmp.distanceTo(localSpherePos); + if(Ray.pointInTriangle(tmp, va, vb, vc) && dist < sphereShape.radius){ + if(justTest){ + return true; + } + var r = this.createContactEquation(sphereBody, trimeshBody, sphereShape, trimeshShape,rsi,rsj); + + tmp.vsub(localSpherePos, r.ni); + r.ni.normalize(); + r.ni.scale(sphereShape.radius, r.ri); + + Transform.pointToWorldFrame(trimeshPos, trimeshQuat, tmp, tmp); + tmp.vsub(trimeshBody.position, r.rj); + + Transform.vectorToWorldFrame(trimeshQuat, r.ni, r.ni); + Transform.vectorToWorldFrame(trimeshQuat, r.ri, r.ri); + + this.result.push(r); + this.createFrictionEquationsFromContact(r, this.frictionResult); + } + } + + triangles.length = 0; +}; + +var point_on_plane_to_sphere = new Vec3(); +var plane_to_sphere_ortho = new Vec3(); + +/** + * @method spherePlane + * @param {Shape} si + * @param {Shape} sj + * @param {Vec3} xi + * @param {Vec3} xj + * @param {Quaternion} qi + * @param {Quaternion} qj + * @param {Body} bi + * @param {Body} bj + */ +Narrowphase.prototype[Shape.types.SPHERE | Shape.types.PLANE] = +Narrowphase.prototype.spherePlane = function(si,sj,xi,xj,qi,qj,bi,bj,rsi,rsj,justTest){ + // We will have one contact in this case + var r = this.createContactEquation(bi,bj,si,sj,rsi,rsj); + + // Contact normal + r.ni.set(0,0,1); + qj.vmult(r.ni, r.ni); + r.ni.negate(r.ni); // body i is the sphere, flip normal + r.ni.normalize(); // Needed? + + // Vector from sphere center to contact point + r.ni.mult(si.radius, r.ri); + + // Project down sphere on plane + xi.vsub(xj, point_on_plane_to_sphere); + r.ni.mult(r.ni.dot(point_on_plane_to_sphere), plane_to_sphere_ortho); + point_on_plane_to_sphere.vsub(plane_to_sphere_ortho,r.rj); // The sphere position projected to plane + + if(-point_on_plane_to_sphere.dot(r.ni) <= si.radius){ + + if(justTest){ + return true; + } + + // Make it relative to the body + var ri = r.ri; + var rj = r.rj; + ri.vadd(xi, ri); + ri.vsub(bi.position, ri); + rj.vadd(xj, rj); + rj.vsub(bj.position, rj); + + this.result.push(r); + this.createFrictionEquationsFromContact(r, this.frictionResult); + } +}; + +// See http://bulletphysics.com/Bullet/BulletFull/SphereTriangleDetector_8cpp_source.html +var pointInPolygon_edge = new Vec3(); +var pointInPolygon_edge_x_normal = new Vec3(); +var pointInPolygon_vtp = new Vec3(); +function pointInPolygon(verts, normal, p){ + var positiveResult = null; + var N = verts.length; + for(var i=0; i!==N; i++){ + var v = verts[i]; + + // Get edge to the next vertex + var edge = pointInPolygon_edge; + verts[(i+1) % (N)].vsub(v,edge); + + // Get cross product between polygon normal and the edge + var edge_x_normal = pointInPolygon_edge_x_normal; + //var edge_x_normal = new Vec3(); + edge.cross(normal,edge_x_normal); + + // Get vector between point and current vertex + var vertex_to_p = pointInPolygon_vtp; + p.vsub(v,vertex_to_p); + + // This dot product determines which side of the edge the point is + var r = edge_x_normal.dot(vertex_to_p); + + // If all such dot products have same sign, we are inside the polygon. + if(positiveResult===null || (r>0 && positiveResult===true) || (r<=0 && positiveResult===false)){ + if(positiveResult===null){ + positiveResult = r>0; + } + continue; + } else { + return false; // Encountered some other sign. Exit. + } + } + + // If we got here, all dot products were of the same sign. + return true; +} + +var box_to_sphere = new Vec3(); +var sphereBox_ns = new Vec3(); +var sphereBox_ns1 = new Vec3(); +var sphereBox_ns2 = new Vec3(); +var sphereBox_sides = [new Vec3(),new Vec3(),new Vec3(),new Vec3(),new Vec3(),new Vec3()]; +var sphereBox_sphere_to_corner = new Vec3(); +var sphereBox_side_ns = new Vec3(); +var sphereBox_side_ns1 = new Vec3(); +var sphereBox_side_ns2 = new Vec3(); + +/** + * @method sphereBox + * @param {Shape} si + * @param {Shape} sj + * @param {Vec3} xi + * @param {Vec3} xj + * @param {Quaternion} qi + * @param {Quaternion} qj + * @param {Body} bi + * @param {Body} bj + */ +Narrowphase.prototype[Shape.types.SPHERE | Shape.types.BOX] = +Narrowphase.prototype.sphereBox = function(si,sj,xi,xj,qi,qj,bi,bj,rsi,rsj,justTest){ + var v3pool = this.v3pool; + + // we refer to the box as body j + var sides = sphereBox_sides; + xi.vsub(xj,box_to_sphere); + sj.getSideNormals(sides,qj); + var R = si.radius; + var penetrating_sides = []; + + // Check side (plane) intersections + var found = false; + + // Store the resulting side penetration info + var side_ns = sphereBox_side_ns; + var side_ns1 = sphereBox_side_ns1; + var side_ns2 = sphereBox_side_ns2; + var side_h = null; + var side_penetrations = 0; + var side_dot1 = 0; + var side_dot2 = 0; + var side_distance = null; + for(var idx=0,nsides=sides.length; idx!==nsides && found===false; idx++){ + // Get the plane side normal (ns) + var ns = sphereBox_ns; + ns.copy(sides[idx]); + + var h = ns.norm(); + ns.normalize(); + + // The normal/distance dot product tells which side of the plane we are + var dot = box_to_sphere.dot(ns); + + if(dot0){ + // Intersects plane. Now check the other two dimensions + var ns1 = sphereBox_ns1; + var ns2 = sphereBox_ns2; + ns1.copy(sides[(idx+1)%3]); + ns2.copy(sides[(idx+2)%3]); + var h1 = ns1.norm(); + var h2 = ns2.norm(); + ns1.normalize(); + ns2.normalize(); + var dot1 = box_to_sphere.dot(ns1); + var dot2 = box_to_sphere.dot(ns2); + if(dot1

-h1 && dot2

-h2){ + var dist = Math.abs(dot-h-R); + if(side_distance===null || dist < side_distance){ + side_distance = dist; + side_dot1 = dot1; + side_dot2 = dot2; + side_h = h; + side_ns.copy(ns); + side_ns1.copy(ns1); + side_ns2.copy(ns2); + side_penetrations++; + + if(justTest){ + return true; + } + } + } + } + } + if(side_penetrations){ + found = true; + var r = this.createContactEquation(bi,bj,si,sj,rsi,rsj); + side_ns.mult(-R,r.ri); // Sphere r + r.ni.copy(side_ns); + r.ni.negate(r.ni); // Normal should be out of sphere + side_ns.mult(side_h,side_ns); + side_ns1.mult(side_dot1,side_ns1); + side_ns.vadd(side_ns1,side_ns); + side_ns2.mult(side_dot2,side_ns2); + side_ns.vadd(side_ns2,r.rj); + + // Make relative to bodies + r.ri.vadd(xi, r.ri); + r.ri.vsub(bi.position, r.ri); + r.rj.vadd(xj, r.rj); + r.rj.vsub(bj.position, r.rj); + + this.result.push(r); + this.createFrictionEquationsFromContact(r, this.frictionResult); + } + + // Check corners + var rj = v3pool.get(); + var sphere_to_corner = sphereBox_sphere_to_corner; + for(var j=0; j!==2 && !found; j++){ + for(var k=0; k!==2 && !found; k++){ + for(var l=0; l!==2 && !found; l++){ + rj.set(0,0,0); + if(j){ + rj.vadd(sides[0],rj); + } else { + rj.vsub(sides[0],rj); + } + if(k){ + rj.vadd(sides[1],rj); + } else { + rj.vsub(sides[1],rj); + } + if(l){ + rj.vadd(sides[2],rj); + } else { + rj.vsub(sides[2],rj); + } + + // World position of corner + xj.vadd(rj,sphere_to_corner); + sphere_to_corner.vsub(xi,sphere_to_corner); + + if(sphere_to_corner.norm2() < R*R){ + if(justTest){ + return true; + } + found = true; + var r = this.createContactEquation(bi,bj,si,sj,rsi,rsj); + r.ri.copy(sphere_to_corner); + r.ri.normalize(); + r.ni.copy(r.ri); + r.ri.mult(R,r.ri); + r.rj.copy(rj); + + // Make relative to bodies + r.ri.vadd(xi, r.ri); + r.ri.vsub(bi.position, r.ri); + r.rj.vadd(xj, r.rj); + r.rj.vsub(bj.position, r.rj); + + this.result.push(r); + this.createFrictionEquationsFromContact(r, this.frictionResult); + } + } + } + } + v3pool.release(rj); + rj = null; + + // Check edges + var edgeTangent = v3pool.get(); + var edgeCenter = v3pool.get(); + var r = v3pool.get(); // r = edge center to sphere center + var orthogonal = v3pool.get(); + var dist = v3pool.get(); + var Nsides = sides.length; + for(var j=0; j!==Nsides && !found; j++){ + for(var k=0; k!==Nsides && !found; k++){ + if(j%3 !== k%3){ + // Get edge tangent + sides[k].cross(sides[j],edgeTangent); + edgeTangent.normalize(); + sides[j].vadd(sides[k], edgeCenter); + r.copy(xi); + r.vsub(edgeCenter,r); + r.vsub(xj,r); + var orthonorm = r.dot(edgeTangent); // distance from edge center to sphere center in the tangent direction + edgeTangent.mult(orthonorm,orthogonal); // Vector from edge center to sphere center in the tangent direction + + // Find the third side orthogonal to this one + var l = 0; + while(l===j%3 || l===k%3){ + l++; + } + + // vec from edge center to sphere projected to the plane orthogonal to the edge tangent + dist.copy(xi); + dist.vsub(orthogonal,dist); + dist.vsub(edgeCenter,dist); + dist.vsub(xj,dist); + + // Distances in tangent direction and distance in the plane orthogonal to it + var tdist = Math.abs(orthonorm); + var ndist = dist.norm(); + + if(tdist < sides[l].norm() && ndist si.boundingSphereRadius + sj.boundingSphereRadius){ + // return; + // } + + // Check corners + for(var i=0; i!==verts.length; i++){ + var v = verts[i]; + + // World position of corner + var worldCorner = sphereConvex_worldCorner; + qj.vmult(v,worldCorner); + xj.vadd(worldCorner,worldCorner); + var sphere_to_corner = sphereConvex_sphereToCorner; + worldCorner.vsub(xi, sphere_to_corner); + if(sphere_to_corner.norm2() < R * R){ + if(justTest){ + return true; + } + found = true; + var r = this.createContactEquation(bi,bj,si,sj,rsi,rsj); + r.ri.copy(sphere_to_corner); + r.ri.normalize(); + r.ni.copy(r.ri); + r.ri.mult(R,r.ri); + worldCorner.vsub(xj,r.rj); + + // Should be relative to the body. + r.ri.vadd(xi, r.ri); + r.ri.vsub(bi.position, r.ri); + + // Should be relative to the body. + r.rj.vadd(xj, r.rj); + r.rj.vsub(bj.position, r.rj); + + this.result.push(r); + this.createFrictionEquationsFromContact(r, this.frictionResult); + return; + } + } + + // Check side (plane) intersections + var found = false; + for(var i=0, nfaces=faces.length; i!==nfaces && found===false; i++){ + var normal = normals[i]; + var face = faces[i]; + + // Get world-transformed normal of the face + var worldNormal = sphereConvex_worldNormal; + qj.vmult(normal,worldNormal); + + // Get a world vertex from the face + var worldPoint = sphereConvex_worldPoint; + qj.vmult(verts[face[0]],worldPoint); + worldPoint.vadd(xj,worldPoint); + + // Get a point on the sphere, closest to the face normal + var worldSpherePointClosestToPlane = sphereConvex_worldSpherePointClosestToPlane; + worldNormal.mult(-R, worldSpherePointClosestToPlane); + xi.vadd(worldSpherePointClosestToPlane, worldSpherePointClosestToPlane); + + // Vector from a face point to the closest point on the sphere + var penetrationVec = sphereConvex_penetrationVec; + worldSpherePointClosestToPlane.vsub(worldPoint,penetrationVec); + + // The penetration. Negative value means overlap. + var penetration = penetrationVec.dot(worldNormal); + + var worldPointToSphere = sphereConvex_sphereToWorldPoint; + xi.vsub(worldPoint, worldPointToSphere); + + if(penetration < 0 && worldPointToSphere.dot(worldNormal)>0){ + // Intersects plane. Now check if the sphere is inside the face polygon + var faceVerts = []; // Face vertices, in world coords + for(var j=0, Nverts=face.length; j!==Nverts; j++){ + var worldVertex = v3pool.get(); + qj.vmult(verts[face[j]], worldVertex); + xj.vadd(worldVertex,worldVertex); + faceVerts.push(worldVertex); + } + + if(pointInPolygon(faceVerts,worldNormal,xi)){ // Is the sphere center in the face polygon? + if(justTest){ + return true; + } + found = true; + var r = this.createContactEquation(bi,bj,si,sj,rsi,rsj); + + worldNormal.mult(-R, r.ri); // Contact offset, from sphere center to contact + worldNormal.negate(r.ni); // Normal pointing out of sphere + + var penetrationVec2 = v3pool.get(); + worldNormal.mult(-penetration, penetrationVec2); + var penetrationSpherePoint = v3pool.get(); + worldNormal.mult(-R, penetrationSpherePoint); + + //xi.vsub(xj).vadd(penetrationSpherePoint).vadd(penetrationVec2 , r.rj); + xi.vsub(xj,r.rj); + r.rj.vadd(penetrationSpherePoint,r.rj); + r.rj.vadd(penetrationVec2 , r.rj); + + // Should be relative to the body. + r.rj.vadd(xj, r.rj); + r.rj.vsub(bj.position, r.rj); + + // Should be relative to the body. + r.ri.vadd(xi, r.ri); + r.ri.vsub(bi.position, r.ri); + + v3pool.release(penetrationVec2); + v3pool.release(penetrationSpherePoint); + + this.result.push(r); + this.createFrictionEquationsFromContact(r, this.frictionResult); + + // Release world vertices + for(var j=0, Nfaceverts=faceVerts.length; j!==Nfaceverts; j++){ + v3pool.release(faceVerts[j]); + } + + return; // We only expect *one* face contact + } else { + // Edge? + for(var j=0; j!==face.length; j++){ + + // Get two world transformed vertices + var v1 = v3pool.get(); + var v2 = v3pool.get(); + qj.vmult(verts[face[(j+1)%face.length]], v1); + qj.vmult(verts[face[(j+2)%face.length]], v2); + xj.vadd(v1, v1); + xj.vadd(v2, v2); + + // Construct edge vector + var edge = sphereConvex_edge; + v2.vsub(v1,edge); + + // Construct the same vector, but normalized + var edgeUnit = sphereConvex_edgeUnit; + edge.unit(edgeUnit); + + // p is xi projected onto the edge + var p = v3pool.get(); + var v1_to_xi = v3pool.get(); + xi.vsub(v1, v1_to_xi); + var dot = v1_to_xi.dot(edgeUnit); + edgeUnit.mult(dot, p); + p.vadd(v1, p); + + // Compute a vector from p to the center of the sphere + var xi_to_p = v3pool.get(); + p.vsub(xi, xi_to_p); + + // Collision if the edge-sphere distance is less than the radius + // AND if p is in between v1 and v2 + if(dot > 0 && dot*dot si.boundingSphereRadius + sj.boundingSphereRadius){ + return; + } + + if(si.findSeparatingAxis(sj,xi,qi,xj,qj,sepAxis,faceListA,faceListB)){ + var res = []; + var q = convexConvex_q; + si.clipAgainstHull(xi,qi,sj,xj,qj,sepAxis,-100,100,res); + var numContacts = 0; + for(var j = 0; j !== res.length; j++){ + if(justTest){ + return true; + } + var r = this.createContactEquation(bi,bj,si,sj,rsi,rsj), + ri = r.ri, + rj = r.rj; + sepAxis.negate(r.ni); + res[j].normal.negate(q); + q.mult(res[j].depth, q); + res[j].point.vadd(q, ri); + rj.copy(res[j].point); + + // Contact points are in world coordinates. Transform back to relative + ri.vsub(xi,ri); + rj.vsub(xj,rj); + + // Make relative to bodies + ri.vadd(xi, ri); + ri.vsub(bi.position, ri); + rj.vadd(xj, rj); + rj.vsub(bj.position, rj); + + this.result.push(r); + numContacts++; + if(!this.enableFrictionReduction){ + this.createFrictionEquationsFromContact(r, this.frictionResult); + } + } + if(this.enableFrictionReduction && numContacts){ + this.createFrictionFromAverage(numContacts); + } + } +}; + + +/** + * @method convexTrimesh + * @param {Array} result + * @param {Shape} si + * @param {Shape} sj + * @param {Vec3} xi + * @param {Vec3} xj + * @param {Quaternion} qi + * @param {Quaternion} qj + * @param {Body} bi + * @param {Body} bj + */ +// Narrowphase.prototype[Shape.types.CONVEXPOLYHEDRON | Shape.types.TRIMESH] = +// Narrowphase.prototype.convexTrimesh = function(si,sj,xi,xj,qi,qj,bi,bj,rsi,rsj,faceListA,faceListB){ +// var sepAxis = convexConvex_sepAxis; + +// if(xi.distanceTo(xj) > si.boundingSphereRadius + sj.boundingSphereRadius){ +// return; +// } + +// // Construct a temp hull for each triangle +// var hullB = new ConvexPolyhedron(); + +// hullB.faces = [[0,1,2]]; +// var va = new Vec3(); +// var vb = new Vec3(); +// var vc = new Vec3(); +// hullB.vertices = [ +// va, +// vb, +// vc +// ]; + +// for (var i = 0; i < sj.indices.length / 3; i++) { + +// var triangleNormal = new Vec3(); +// sj.getNormal(i, triangleNormal); +// hullB.faceNormals = [triangleNormal]; + +// sj.getTriangleVertices(i, va, vb, vc); + +// var d = si.testSepAxis(triangleNormal, hullB, xi, qi, xj, qj); +// if(!d){ +// triangleNormal.scale(-1, triangleNormal); +// d = si.testSepAxis(triangleNormal, hullB, xi, qi, xj, qj); + +// if(!d){ +// continue; +// } +// } + +// var res = []; +// var q = convexConvex_q; +// si.clipAgainstHull(xi,qi,hullB,xj,qj,triangleNormal,-100,100,res); +// for(var j = 0; j !== res.length; j++){ +// var r = this.createContactEquation(bi,bj,si,sj,rsi,rsj), +// ri = r.ri, +// rj = r.rj; +// r.ni.copy(triangleNormal); +// r.ni.negate(r.ni); +// res[j].normal.negate(q); +// q.mult(res[j].depth, q); +// res[j].point.vadd(q, ri); +// rj.copy(res[j].point); + +// // Contact points are in world coordinates. Transform back to relative +// ri.vsub(xi,ri); +// rj.vsub(xj,rj); + +// // Make relative to bodies +// ri.vadd(xi, ri); +// ri.vsub(bi.position, ri); +// rj.vadd(xj, rj); +// rj.vsub(bj.position, rj); + +// result.push(r); +// } +// } +// }; + +var particlePlane_normal = new Vec3(); +var particlePlane_relpos = new Vec3(); +var particlePlane_projected = new Vec3(); + +/** + * @method particlePlane + * @param {Array} result + * @param {Shape} si + * @param {Shape} sj + * @param {Vec3} xi + * @param {Vec3} xj + * @param {Quaternion} qi + * @param {Quaternion} qj + * @param {Body} bi + * @param {Body} bj + */ +Narrowphase.prototype[Shape.types.PLANE | Shape.types.PARTICLE] = +Narrowphase.prototype.planeParticle = function(sj,si,xj,xi,qj,qi,bj,bi,rsi,rsj,justTest){ + var normal = particlePlane_normal; + normal.set(0,0,1); + bj.quaternion.vmult(normal,normal); // Turn normal according to plane orientation + var relpos = particlePlane_relpos; + xi.vsub(bj.position,relpos); + var dot = normal.dot(relpos); + if(dot <= 0.0){ + + if(justTest){ + return true; + } + + var r = this.createContactEquation(bi,bj,si,sj,rsi,rsj); + r.ni.copy(normal); // Contact normal is the plane normal + r.ni.negate(r.ni); + r.ri.set(0,0,0); // Center of particle + + // Get particle position projected on plane + var projected = particlePlane_projected; + normal.mult(normal.dot(xi),projected); + xi.vsub(projected,projected); + //projected.vadd(bj.position,projected); + + // rj is now the projected world position minus plane position + r.rj.copy(projected); + this.result.push(r); + this.createFrictionEquationsFromContact(r, this.frictionResult); + } +}; + +var particleSphere_normal = new Vec3(); + +/** + * @method particleSphere + * @param {Array} result + * @param {Shape} si + * @param {Shape} sj + * @param {Vec3} xi + * @param {Vec3} xj + * @param {Quaternion} qi + * @param {Quaternion} qj + * @param {Body} bi + * @param {Body} bj + */ +Narrowphase.prototype[Shape.types.PARTICLE | Shape.types.SPHERE] = +Narrowphase.prototype.sphereParticle = function(sj,si,xj,xi,qj,qi,bj,bi,rsi,rsj,justTest){ + // The normal is the unit vector from sphere center to particle center + var normal = particleSphere_normal; + normal.set(0,0,1); + xi.vsub(xj,normal); + var lengthSquared = normal.norm2(); + + if(lengthSquared <= sj.radius * sj.radius){ + if(justTest){ + return true; + } + var r = this.createContactEquation(bi,bj,si,sj,rsi,rsj); + normal.normalize(); + r.rj.copy(normal); + r.rj.mult(sj.radius,r.rj); + r.ni.copy(normal); // Contact normal + r.ni.negate(r.ni); + r.ri.set(0,0,0); // Center of particle + this.result.push(r); + this.createFrictionEquationsFromContact(r, this.frictionResult); + } +}; + +// WIP +var cqj = new Quaternion(); +var convexParticle_local = new Vec3(); +var convexParticle_normal = new Vec3(); +var convexParticle_penetratedFaceNormal = new Vec3(); +var convexParticle_vertexToParticle = new Vec3(); +var convexParticle_worldPenetrationVec = new Vec3(); + +/** + * @method convexParticle + * @param {Array} result + * @param {Shape} si + * @param {Shape} sj + * @param {Vec3} xi + * @param {Vec3} xj + * @param {Quaternion} qi + * @param {Quaternion} qj + * @param {Body} bi + * @param {Body} bj + */ +Narrowphase.prototype[Shape.types.PARTICLE | Shape.types.CONVEXPOLYHEDRON] = +Narrowphase.prototype.convexParticle = function(sj,si,xj,xi,qj,qi,bj,bi,rsi,rsj,justTest){ + var penetratedFaceIndex = -1; + var penetratedFaceNormal = convexParticle_penetratedFaceNormal; + var worldPenetrationVec = convexParticle_worldPenetrationVec; + var minPenetration = null; + var numDetectedFaces = 0; + + // Convert particle position xi to local coords in the convex + var local = convexParticle_local; + local.copy(xi); + local.vsub(xj,local); // Convert position to relative the convex origin + qj.conjugate(cqj); + cqj.vmult(local,local); + + if(sj.pointIsInside(local)){ + + if(sj.worldVerticesNeedsUpdate){ + sj.computeWorldVertices(xj,qj); + } + if(sj.worldFaceNormalsNeedsUpdate){ + sj.computeWorldFaceNormals(qj); + } + + // For each world polygon in the polyhedra + for(var i=0,nfaces=sj.faces.length; i!==nfaces; i++){ + + // Construct world face vertices + var verts = [ sj.worldVertices[ sj.faces[i][0] ] ]; + var normal = sj.worldFaceNormals[i]; + + // Check how much the particle penetrates the polygon plane. + xi.vsub(verts[0],convexParticle_vertexToParticle); + var penetration = -normal.dot(convexParticle_vertexToParticle); + if(minPenetration===null || Math.abs(penetration) data.length || iMinY > data[0].length){ + return; + } + + // Clamp index to edges + if(iMinX < 0){ iMinX = 0; } + if(iMaxX < 0){ iMaxX = 0; } + if(iMinY < 0){ iMinY = 0; } + if(iMaxY < 0){ iMaxY = 0; } + if(iMinX >= data.length){ iMinX = data.length - 1; } + if(iMaxX >= data.length){ iMaxX = data.length - 1; } + if(iMaxY >= data[0].length){ iMaxY = data[0].length - 1; } + if(iMinY >= data[0].length){ iMinY = data[0].length - 1; } + + var minMax = []; + hfShape.getRectMinMax(iMinX, iMinY, iMaxX, iMaxY, minMax); + var min = minMax[0]; + var max = minMax[1]; + + // Bail out if we're cant touch the bounding height box + if(localConvexPos.z - radius > max || localConvexPos.z + radius < min){ + return; + } + + for(var i = iMinX; i < iMaxX; i++){ + for(var j = iMinY; j < iMaxY; j++){ + + var intersecting = false; + + // Lower triangle + hfShape.getConvexTrianglePillar(i, j, false); + Transform.pointToWorldFrame(hfPos, hfQuat, hfShape.pillarOffset, worldPillarOffset); + if (convexPos.distanceTo(worldPillarOffset) < hfShape.pillarConvex.boundingSphereRadius + convexShape.boundingSphereRadius) { + intersecting = this.convexConvex(convexShape, hfShape.pillarConvex, convexPos, worldPillarOffset, convexQuat, hfQuat, convexBody, hfBody, null, null, justTest, faceList, null); + } + + if(justTest && intersecting){ + return true; + } + + // Upper triangle + hfShape.getConvexTrianglePillar(i, j, true); + Transform.pointToWorldFrame(hfPos, hfQuat, hfShape.pillarOffset, worldPillarOffset); + if (convexPos.distanceTo(worldPillarOffset) < hfShape.pillarConvex.boundingSphereRadius + convexShape.boundingSphereRadius) { + intersecting = this.convexConvex(convexShape, hfShape.pillarConvex, convexPos, worldPillarOffset, convexQuat, hfQuat, convexBody, hfBody, null, null, justTest, faceList, null); + } + + if(justTest && intersecting){ + return true; + } + } + } +}; + +var sphereHeightfield_tmp1 = new Vec3(); +var sphereHeightfield_tmp2 = new Vec3(); + +/** + * @method sphereHeightfield + */ +Narrowphase.prototype[Shape.types.SPHERE | Shape.types.HEIGHTFIELD] = +Narrowphase.prototype.sphereHeightfield = function ( + sphereShape, + hfShape, + spherePos, + hfPos, + sphereQuat, + hfQuat, + sphereBody, + hfBody, + rsi, + rsj, + justTest +){ + var data = hfShape.data, + radius = sphereShape.radius, + w = hfShape.elementSize, + worldPillarOffset = sphereHeightfield_tmp2; + + // Get sphere position to heightfield local! + var localSpherePos = sphereHeightfield_tmp1; + Transform.pointToLocalFrame(hfPos, hfQuat, spherePos, localSpherePos); + + // Get the index of the data points to test against + var iMinX = Math.floor((localSpherePos.x - radius) / w) - 1, + iMaxX = Math.ceil((localSpherePos.x + radius) / w) + 1, + iMinY = Math.floor((localSpherePos.y - radius) / w) - 1, + iMaxY = Math.ceil((localSpherePos.y + radius) / w) + 1; + + // Bail out if we are out of the terrain + if(iMaxX < 0 || iMaxY < 0 || iMinX > data.length || iMaxY > data[0].length){ + return; + } + + // Clamp index to edges + if(iMinX < 0){ iMinX = 0; } + if(iMaxX < 0){ iMaxX = 0; } + if(iMinY < 0){ iMinY = 0; } + if(iMaxY < 0){ iMaxY = 0; } + if(iMinX >= data.length){ iMinX = data.length - 1; } + if(iMaxX >= data.length){ iMaxX = data.length - 1; } + if(iMaxY >= data[0].length){ iMaxY = data[0].length - 1; } + if(iMinY >= data[0].length){ iMinY = data[0].length - 1; } + + var minMax = []; + hfShape.getRectMinMax(iMinX, iMinY, iMaxX, iMaxY, minMax); + var min = minMax[0]; + var max = minMax[1]; + + // Bail out if we're cant touch the bounding height box + if(localSpherePos.z - radius > max || localSpherePos.z + radius < min){ + return; + } + + var result = this.result; + for(var i = iMinX; i < iMaxX; i++){ + for(var j = iMinY; j < iMaxY; j++){ + + var numContactsBefore = result.length; + + var intersecting = false; + + // Lower triangle + hfShape.getConvexTrianglePillar(i, j, false); + Transform.pointToWorldFrame(hfPos, hfQuat, hfShape.pillarOffset, worldPillarOffset); + if (spherePos.distanceTo(worldPillarOffset) < hfShape.pillarConvex.boundingSphereRadius + sphereShape.boundingSphereRadius) { + intersecting = this.sphereConvex(sphereShape, hfShape.pillarConvex, spherePos, worldPillarOffset, sphereQuat, hfQuat, sphereBody, hfBody, sphereShape, hfShape, justTest); + } + + if(justTest && intersecting){ + return true; + } + + // Upper triangle + hfShape.getConvexTrianglePillar(i, j, true); + Transform.pointToWorldFrame(hfPos, hfQuat, hfShape.pillarOffset, worldPillarOffset); + if (spherePos.distanceTo(worldPillarOffset) < hfShape.pillarConvex.boundingSphereRadius + sphereShape.boundingSphereRadius) { + intersecting = this.sphereConvex(sphereShape, hfShape.pillarConvex, spherePos, worldPillarOffset, sphereQuat, hfQuat, sphereBody, hfBody, sphereShape, hfShape, justTest); + } + + if(justTest && intersecting){ + return true; + } + + var numContacts = result.length - numContactsBefore; + + if(numContacts > 2){ + return; + } + /* + // Skip all but 1 + for (var k = 0; k < numContacts - 1; k++) { + result.pop(); + } + */ + } + } +}; + +},{"../collision/AABB":3,"../collision/Ray":10,"../equations/ContactEquation":20,"../equations/FrictionEquation":22,"../math/Quaternion":29,"../math/Transform":30,"../math/Vec3":31,"../objects/Body":32,"../shapes/ConvexPolyhedron":39,"../shapes/Shape":44,"../solver/Solver":48,"../utils/Vec3Pool":55}],57:[function(require,module,exports){ +/* global performance */ + +module.exports = World; + +var Shape = require('../shapes/Shape'); +var Vec3 = require('../math/Vec3'); +var Quaternion = require('../math/Quaternion'); +var GSSolver = require('../solver/GSSolver'); +var ContactEquation = require('../equations/ContactEquation'); +var FrictionEquation = require('../equations/FrictionEquation'); +var Narrowphase = require('./Narrowphase'); +var EventTarget = require('../utils/EventTarget'); +var ArrayCollisionMatrix = require('../collision/ArrayCollisionMatrix'); +var OverlapKeeper = require('../collision/OverlapKeeper'); +var Material = require('../material/Material'); +var ContactMaterial = require('../material/ContactMaterial'); +var Body = require('../objects/Body'); +var TupleDictionary = require('../utils/TupleDictionary'); +var RaycastResult = require('../collision/RaycastResult'); +var AABB = require('../collision/AABB'); +var Ray = require('../collision/Ray'); +var NaiveBroadphase = require('../collision/NaiveBroadphase'); + +/** + * The physics world + * @class World + * @constructor + * @extends EventTarget + * @param {object} [options] + * @param {Vec3} [options.gravity] + * @param {boolean} [options.allowSleep] + * @param {Broadphase} [options.broadphase] + * @param {Solver} [options.solver] + * @param {boolean} [options.quatNormalizeFast] + * @param {number} [options.quatNormalizeSkip] + */ +function World(options){ + options = options || {}; + EventTarget.apply(this); + + /** + * Currently / last used timestep. Is set to -1 if not available. This value is updated before each internal step, which means that it is "fresh" inside event callbacks. + * @property {Number} dt + */ + this.dt = -1; + + /** + * Makes bodies go to sleep when they've been inactive + * @property allowSleep + * @type {Boolean} + * @default false + */ + this.allowSleep = !!options.allowSleep; + + /** + * All the current contacts (instances of ContactEquation) in the world. + * @property contacts + * @type {Array} + */ + this.contacts = []; + this.frictionEquations = []; + + /** + * How often to normalize quaternions. Set to 0 for every step, 1 for every second etc.. A larger value increases performance. If bodies tend to explode, set to a smaller value (zero to be sure nothing can go wrong). + * @property quatNormalizeSkip + * @type {Number} + * @default 0 + */ + this.quatNormalizeSkip = options.quatNormalizeSkip !== undefined ? options.quatNormalizeSkip : 0; + + /** + * Set to true to use fast quaternion normalization. It is often enough accurate to use. If bodies tend to explode, set to false. + * @property quatNormalizeFast + * @type {Boolean} + * @see Quaternion.normalizeFast + * @see Quaternion.normalize + * @default false + */ + this.quatNormalizeFast = options.quatNormalizeFast !== undefined ? options.quatNormalizeFast : false; + + /** + * The wall-clock time since simulation start + * @property time + * @type {Number} + */ + this.time = 0.0; + + /** + * Number of timesteps taken since start + * @property stepnumber + * @type {Number} + */ + this.stepnumber = 0; + + /// Default and last timestep sizes + this.default_dt = 1/60; + + this.nextId = 0; + /** + * @property gravity + * @type {Vec3} + */ + this.gravity = new Vec3(); + if(options.gravity){ + this.gravity.copy(options.gravity); + } + + /** + * The broadphase algorithm to use. Default is NaiveBroadphase + * @property broadphase + * @type {Broadphase} + */ + this.broadphase = options.broadphase !== undefined ? options.broadphase : new NaiveBroadphase(); + + /** + * @property bodies + * @type {Array} + */ + this.bodies = []; + + /** + * The solver algorithm to use. Default is GSSolver + * @property solver + * @type {Solver} + */ + this.solver = options.solver !== undefined ? options.solver : new GSSolver(); + + /** + * @property constraints + * @type {Array} + */ + this.constraints = []; + + /** + * @property narrowphase + * @type {Narrowphase} + */ + this.narrowphase = new Narrowphase(this); + + /** + * @property {ArrayCollisionMatrix} collisionMatrix + * @type {ArrayCollisionMatrix} + */ + this.collisionMatrix = new ArrayCollisionMatrix(); + + /** + * CollisionMatrix from the previous step. + * @property {ArrayCollisionMatrix} collisionMatrixPrevious + * @type {ArrayCollisionMatrix} + */ + this.collisionMatrixPrevious = new ArrayCollisionMatrix(); + + this.bodyOverlapKeeper = new OverlapKeeper(); + this.shapeOverlapKeeper = new OverlapKeeper(); + + /** + * All added materials + * @property materials + * @type {Array} + */ + this.materials = []; + + /** + * @property contactmaterials + * @type {Array} + */ + this.contactmaterials = []; + + /** + * Used to look up a ContactMaterial given two instances of Material. + * @property {TupleDictionary} contactMaterialTable + */ + this.contactMaterialTable = new TupleDictionary(); + + this.defaultMaterial = new Material("default"); + + /** + * This contact material is used if no suitable contactmaterial is found for a contact. + * @property defaultContactMaterial + * @type {ContactMaterial} + */ + this.defaultContactMaterial = new ContactMaterial(this.defaultMaterial, this.defaultMaterial, { friction: 0.3, restitution: 0.0 }); + + /** + * @property doProfiling + * @type {Boolean} + */ + this.doProfiling = false; + + /** + * @property profile + * @type {Object} + */ + this.profile = { + solve:0, + makeContactConstraints:0, + broadphase:0, + integrate:0, + narrowphase:0, + }; + + /** + * Time accumulator for interpolation. See http://gafferongames.com/game-physics/fix-your-timestep/ + * @property {Number} accumulator + */ + this.accumulator = 0; + + /** + * @property subsystems + * @type {Array} + */ + this.subsystems = []; + + /** + * Dispatched after a body has been added to the world. + * @event addBody + * @param {Body} body The body that has been added to the world. + */ + this.addBodyEvent = { + type:"addBody", + body : null + }; + + /** + * Dispatched after a body has been removed from the world. + * @event removeBody + * @param {Body} body The body that has been removed from the world. + */ + this.removeBodyEvent = { + type:"removeBody", + body : null + }; + + this.idToBodyMap = {}; + + this.broadphase.setWorld(this); +} +World.prototype = new EventTarget(); + +// Temp stuff +var tmpAABB1 = new AABB(); +var tmpArray1 = []; +var tmpRay = new Ray(); + +/** + * Get the contact material between materials m1 and m2 + * @method getContactMaterial + * @param {Material} m1 + * @param {Material} m2 + * @return {ContactMaterial} The contact material if it was found. + */ +World.prototype.getContactMaterial = function(m1,m2){ + return this.contactMaterialTable.get(m1.id,m2.id); //this.contactmaterials[this.mats2cmat[i+j*this.materials.length]]; +}; + +/** + * Get number of objects in the world. + * @method numObjects + * @return {Number} + * @deprecated + */ +World.prototype.numObjects = function(){ + return this.bodies.length; +}; + +/** + * Store old collision state info + * @method collisionMatrixTick + */ +World.prototype.collisionMatrixTick = function(){ + var temp = this.collisionMatrixPrevious; + this.collisionMatrixPrevious = this.collisionMatrix; + this.collisionMatrix = temp; + this.collisionMatrix.reset(); + + this.bodyOverlapKeeper.tick(); + this.shapeOverlapKeeper.tick(); +}; + +/** + * Add a rigid body to the simulation. + * @method add + * @param {Body} body + * @todo If the simulation has not yet started, why recrete and copy arrays for each body? Accumulate in dynamic arrays in this case. + * @todo Adding an array of bodies should be possible. This would save some loops too + * @deprecated Use .addBody instead + */ +World.prototype.add = World.prototype.addBody = function(body){ + if(this.bodies.indexOf(body) !== -1){ + return; + } + body.index = this.bodies.length; + this.bodies.push(body); + body.world = this; + body.initPosition.copy(body.position); + body.initVelocity.copy(body.velocity); + body.timeLastSleepy = this.time; + if(body instanceof Body){ + body.initAngularVelocity.copy(body.angularVelocity); + body.initQuaternion.copy(body.quaternion); + } + this.collisionMatrix.setNumObjects(this.bodies.length); + this.addBodyEvent.body = body; + this.idToBodyMap[body.id] = body; + this.dispatchEvent(this.addBodyEvent); +}; + +/** + * Add a constraint to the simulation. + * @method addConstraint + * @param {Constraint} c + */ +World.prototype.addConstraint = function(c){ + this.constraints.push(c); +}; + +/** + * Removes a constraint + * @method removeConstraint + * @param {Constraint} c + */ +World.prototype.removeConstraint = function(c){ + var idx = this.constraints.indexOf(c); + if(idx!==-1){ + this.constraints.splice(idx,1); + } +}; + +/** + * Raycast test + * @method rayTest + * @param {Vec3} from + * @param {Vec3} to + * @param {RaycastResult} result + * @deprecated Use .raycastAll, .raycastClosest or .raycastAny instead. + */ +World.prototype.rayTest = function(from, to, result){ + if(result instanceof RaycastResult){ + // Do raycastclosest + this.raycastClosest(from, to, { + skipBackfaces: true + }, result); + } else { + // Do raycastAll + this.raycastAll(from, to, { + skipBackfaces: true + }, result); + } +}; + +/** + * Ray cast against all bodies. The provided callback will be executed for each hit with a RaycastResult as single argument. + * @method raycastAll + * @param {Vec3} from + * @param {Vec3} to + * @param {Object} options + * @param {number} [options.collisionFilterMask=-1] + * @param {number} [options.collisionFilterGroup=-1] + * @param {boolean} [options.skipBackfaces=false] + * @param {boolean} [options.checkCollisionResponse=true] + * @param {Function} callback + * @return {boolean} True if any body was hit. + */ +World.prototype.raycastAll = function(from, to, options, callback){ + options.mode = Ray.ALL; + options.from = from; + options.to = to; + options.callback = callback; + return tmpRay.intersectWorld(this, options); +}; + +/** + * Ray cast, and stop at the first result. Note that the order is random - but the method is fast. + * @method raycastAny + * @param {Vec3} from + * @param {Vec3} to + * @param {Object} options + * @param {number} [options.collisionFilterMask=-1] + * @param {number} [options.collisionFilterGroup=-1] + * @param {boolean} [options.skipBackfaces=false] + * @param {boolean} [options.checkCollisionResponse=true] + * @param {RaycastResult} result + * @return {boolean} True if any body was hit. + */ +World.prototype.raycastAny = function(from, to, options, result){ + options.mode = Ray.ANY; + options.from = from; + options.to = to; + options.result = result; + return tmpRay.intersectWorld(this, options); +}; + +/** + * Ray cast, and return information of the closest hit. + * @method raycastClosest + * @param {Vec3} from + * @param {Vec3} to + * @param {Object} options + * @param {number} [options.collisionFilterMask=-1] + * @param {number} [options.collisionFilterGroup=-1] + * @param {boolean} [options.skipBackfaces=false] + * @param {boolean} [options.checkCollisionResponse=true] + * @param {RaycastResult} result + * @return {boolean} True if any body was hit. + */ +World.prototype.raycastClosest = function(from, to, options, result){ + options.mode = Ray.CLOSEST; + options.from = from; + options.to = to; + options.result = result; + return tmpRay.intersectWorld(this, options); +}; + +/** + * Remove a rigid body from the simulation. + * @method remove + * @param {Body} body + * @deprecated Use .removeBody instead + */ +World.prototype.remove = function(body){ + body.world = null; + var n = this.bodies.length - 1, + bodies = this.bodies, + idx = bodies.indexOf(body); + if(idx !== -1){ + bodies.splice(idx, 1); // Todo: should use a garbage free method + + // Recompute index + for(var i=0; i!==bodies.length; i++){ + bodies[i].index = i; + } + + this.collisionMatrix.setNumObjects(n); + this.removeBodyEvent.body = body; + delete this.idToBodyMap[body.id]; + this.dispatchEvent(this.removeBodyEvent); + } +}; + +/** + * Remove a rigid body from the simulation. + * @method removeBody + * @param {Body} body + */ +World.prototype.removeBody = World.prototype.remove; + +World.prototype.getBodyById = function(id){ + return this.idToBodyMap[id]; +}; + +// TODO Make a faster map +World.prototype.getShapeById = function(id){ + var bodies = this.bodies; + for(var i=0, bl = bodies.length; i= dt && substeps < maxSubSteps) { + // Do fixed steps to catch up + this.internalStep(dt); + this.accumulator -= dt; + substeps++; + } + + var t = (this.accumulator % dt) / dt; + for(var j=0; j !== this.bodies.length; j++){ + var b = this.bodies[j]; + b.previousPosition.lerp(b.position, t, b.interpolatedPosition); + b.previousQuaternion.slerp(b.quaternion, t, b.interpolatedQuaternion); + b.previousQuaternion.normalize(); + } + this.time += timeSinceLastCalled; + } +}; + +var + /** + * Dispatched after the world has stepped forward in time. + * @event postStep + */ + World_step_postStepEvent = {type:"postStep"}, // Reusable event objects to save memory + /** + * Dispatched before the world steps forward in time. + * @event preStep + */ + World_step_preStepEvent = {type:"preStep"}, + World_step_collideEvent = {type:Body.COLLIDE_EVENT_NAME, body:null, contact:null }, + World_step_oldContacts = [], // Pools for unused objects + World_step_frictionEquationPool = [], + World_step_p1 = [], // Reusable arrays for collision pairs + World_step_p2 = [], + World_step_gvec = new Vec3(), // Temporary vectors and quats + World_step_vi = new Vec3(), + World_step_vj = new Vec3(), + World_step_wi = new Vec3(), + World_step_wj = new Vec3(), + World_step_t1 = new Vec3(), + World_step_t2 = new Vec3(), + World_step_rixn = new Vec3(), + World_step_rjxn = new Vec3(), + World_step_step_q = new Quaternion(), + World_step_step_w = new Quaternion(), + World_step_step_wq = new Quaternion(), + invI_tau_dt = new Vec3(); +World.prototype.internalStep = function(dt){ + this.dt = dt; + + var world = this, + that = this, + contacts = this.contacts, + p1 = World_step_p1, + p2 = World_step_p2, + N = this.numObjects(), + bodies = this.bodies, + solver = this.solver, + gravity = this.gravity, + doProfiling = this.doProfiling, + profile = this.profile, + DYNAMIC = Body.DYNAMIC, + profilingStart, + constraints = this.constraints, + frictionEquationPool = World_step_frictionEquationPool, + gnorm = gravity.norm(), + gx = gravity.x, + gy = gravity.y, + gz = gravity.z, + i=0; + + if(doProfiling){ + profilingStart = performance.now(); + } + + // Add gravity to all objects + for(i=0; i!==N; i++){ + var bi = bodies[i]; + if(bi.type === DYNAMIC){ // Only for dynamic bodies + var f = bi.force, m = bi.mass; + f.x += m*gx; + f.y += m*gy; + f.z += m*gz; + } + } + + // Update subsystems + for(var i=0, Nsubsystems=this.subsystems.length; i!==Nsubsystems; i++){ + this.subsystems[i].update(); + } + + // Collision detection + if(doProfiling){ profilingStart = performance.now(); } + p1.length = 0; // Clean up pair arrays from last step + p2.length = 0; + this.broadphase.collisionPairs(this,p1,p2); + if(doProfiling){ profile.broadphase = performance.now() - profilingStart; } + + // Remove constrained pairs with collideConnected == false + var Nconstraints = constraints.length; + for(i=0; i!==Nconstraints; i++){ + var c = constraints[i]; + if(!c.collideConnected){ + for(var j = p1.length-1; j>=0; j-=1){ + if( (c.bodyA === p1[j] && c.bodyB === p2[j]) || + (c.bodyB === p1[j] && c.bodyA === p2[j])){ + p1.splice(j, 1); + p2.splice(j, 1); + } + } + } + } + + this.collisionMatrixTick(); + + // Generate contacts + if(doProfiling){ profilingStart = performance.now(); } + var oldcontacts = World_step_oldContacts; + var NoldContacts = contacts.length; + + for(i=0; i!==NoldContacts; i++){ + oldcontacts.push(contacts[i]); + } + contacts.length = 0; + + // Transfer FrictionEquation from current list to the pool for reuse + var NoldFrictionEquations = this.frictionEquations.length; + for(i=0; i!==NoldFrictionEquations; i++){ + frictionEquationPool.push(this.frictionEquations[i]); + } + this.frictionEquations.length = 0; + + this.narrowphase.getContacts( + p1, + p2, + this, + contacts, + oldcontacts, // To be reused + this.frictionEquations, + frictionEquationPool + ); + + if(doProfiling){ + profile.narrowphase = performance.now() - profilingStart; + } + + // Loop over all collisions + if(doProfiling){ + profilingStart = performance.now(); + } + + // Add all friction eqs + for (var i = 0; i < this.frictionEquations.length; i++) { + solver.addEquation(this.frictionEquations[i]); + } + + var ncontacts = contacts.length; + for(var k=0; k!==ncontacts; k++){ + + // Current contact + var c = contacts[k]; + + // Get current collision indeces + var bi = c.bi, + bj = c.bj, + si = c.si, + sj = c.sj; + + // Get collision properties + var cm; + if(bi.material && bj.material){ + cm = this.getContactMaterial(bi.material,bj.material) || this.defaultContactMaterial; + } else { + cm = this.defaultContactMaterial; + } + + // c.enabled = bi.collisionResponse && bj.collisionResponse && si.collisionResponse && sj.collisionResponse; + + var mu = cm.friction; + // c.restitution = cm.restitution; + + // If friction or restitution were specified in the material, use them + if(bi.material && bj.material){ + if(bi.material.friction >= 0 && bj.material.friction >= 0){ + mu = bi.material.friction * bj.material.friction; + } + + if(bi.material.restitution >= 0 && bj.material.restitution >= 0){ + c.restitution = bi.material.restitution * bj.material.restitution; + } + } + + // c.setSpookParams( + // cm.contactEquationStiffness, + // cm.contactEquationRelaxation, + // dt + // ); + + solver.addEquation(c); + + // // Add friction constraint equation + // if(mu > 0){ + + // // Create 2 tangent equations + // var mug = mu * gnorm; + // var reducedMass = (bi.invMass + bj.invMass); + // if(reducedMass > 0){ + // reducedMass = 1/reducedMass; + // } + // var pool = frictionEquationPool; + // var c1 = pool.length ? pool.pop() : new FrictionEquation(bi,bj,mug*reducedMass); + // var c2 = pool.length ? pool.pop() : new FrictionEquation(bi,bj,mug*reducedMass); + // this.frictionEquations.push(c1, c2); + + // c1.bi = c2.bi = bi; + // c1.bj = c2.bj = bj; + // c1.minForce = c2.minForce = -mug*reducedMass; + // c1.maxForce = c2.maxForce = mug*reducedMass; + + // // Copy over the relative vectors + // c1.ri.copy(c.ri); + // c1.rj.copy(c.rj); + // c2.ri.copy(c.ri); + // c2.rj.copy(c.rj); + + // // Construct tangents + // c.ni.tangents(c1.t, c2.t); + + // // Set spook params + // c1.setSpookParams(cm.frictionEquationStiffness, cm.frictionEquationRelaxation, dt); + // c2.setSpookParams(cm.frictionEquationStiffness, cm.frictionEquationRelaxation, dt); + + // c1.enabled = c2.enabled = c.enabled; + + // // Add equations to solver + // solver.addEquation(c1); + // solver.addEquation(c2); + // } + + if( bi.allowSleep && + bi.type === Body.DYNAMIC && + bi.sleepState === Body.SLEEPING && + bj.sleepState === Body.AWAKE && + bj.type !== Body.STATIC + ){ + var speedSquaredB = bj.velocity.norm2() + bj.angularVelocity.norm2(); + var speedLimitSquaredB = Math.pow(bj.sleepSpeedLimit,2); + if(speedSquaredB >= speedLimitSquaredB*2){ + bi._wakeUpAfterNarrowphase = true; + } + } + + if( bj.allowSleep && + bj.type === Body.DYNAMIC && + bj.sleepState === Body.SLEEPING && + bi.sleepState === Body.AWAKE && + bi.type !== Body.STATIC + ){ + var speedSquaredA = bi.velocity.norm2() + bi.angularVelocity.norm2(); + var speedLimitSquaredA = Math.pow(bi.sleepSpeedLimit,2); + if(speedSquaredA >= speedLimitSquaredA*2){ + bj._wakeUpAfterNarrowphase = true; + } + } + + // Now we know that i and j are in contact. Set collision matrix state + this.collisionMatrix.set(bi, bj, true); + + if (!this.collisionMatrixPrevious.get(bi, bj)) { + // First contact! + // We reuse the collideEvent object, otherwise we will end up creating new objects for each new contact, even if there's no event listener attached. + World_step_collideEvent.body = bj; + World_step_collideEvent.contact = c; + bi.dispatchEvent(World_step_collideEvent); + + World_step_collideEvent.body = bi; + bj.dispatchEvent(World_step_collideEvent); + } + + this.bodyOverlapKeeper.set(bi.id, bj.id); + this.shapeOverlapKeeper.set(si.id, sj.id); + } + + this.emitContactEvents(); + + if(doProfiling){ + profile.makeContactConstraints = performance.now() - profilingStart; + profilingStart = performance.now(); + } + + // Wake up bodies + for(i=0; i!==N; i++){ + var bi = bodies[i]; + if(bi._wakeUpAfterNarrowphase){ + bi.wakeUp(); + bi._wakeUpAfterNarrowphase = false; + } + } + + // Add user-added constraints + var Nconstraints = constraints.length; + for(i=0; i!==Nconstraints; i++){ + var c = constraints[i]; + c.update(); + for(var j=0, Neq=c.equations.length; j!==Neq; j++){ + var eq = c.equations[j]; + solver.addEquation(eq); + } + } + + // Solve the constrained system + solver.solve(dt,this); + + if(doProfiling){ + profile.solve = performance.now() - profilingStart; + } + + // Remove all contacts from solver + solver.removeAllEquations(); + + // Apply damping, see http://code.google.com/p/bullet/issues/detail?id=74 for details + var pow = Math.pow; + for(i=0; i!==N; i++){ + var bi = bodies[i]; + if(bi.type & DYNAMIC){ // Only for dynamic bodies + var ld = pow(1.0 - bi.linearDamping,dt); + var v = bi.velocity; + v.mult(ld,v); + var av = bi.angularVelocity; + if(av){ + var ad = pow(1.0 - bi.angularDamping,dt); + av.mult(ad,av); + } + } + } + + this.dispatchEvent(World_step_preStepEvent); + + // Invoke pre-step callbacks + for(i=0; i!==N; i++){ + var bi = bodies[i]; + if(bi.preStep){ + bi.preStep.call(bi); + } + } + + // Leap frog + // vnew = v + h*f/m + // xnew = x + h*vnew + if(doProfiling){ + profilingStart = performance.now(); + } + var stepnumber = this.stepnumber; + var quatNormalize = stepnumber % (this.quatNormalizeSkip + 1) === 0; + var quatNormalizeFast = this.quatNormalizeFast; + + for(i=0; i!==N; i++){ + bodies[i].integrate(dt, quatNormalize, quatNormalizeFast); + } + this.clearForces(); + + this.broadphase.dirty = true; + + if(doProfiling){ + profile.integrate = performance.now() - profilingStart; + } + + // Update world time + this.time += dt; + this.stepnumber += 1; + + this.dispatchEvent(World_step_postStepEvent); + + // Invoke post-step callbacks + for(i=0; i!==N; i++){ + var bi = bodies[i]; + var postStep = bi.postStep; + if(postStep){ + postStep.call(bi); + } + } + + // Sleeping update + if(this.allowSleep){ + for(i=0; i!==N; i++){ + bodies[i].sleepTick(this.time); + } + } +}; + +World.prototype.emitContactEvents = (function(){ + var additions = []; + var removals = []; + var beginContactEvent = { + type: 'beginContact', + bodyA: null, + bodyB: null + }; + var endContactEvent = { + type: 'endContact', + bodyA: null, + bodyB: null + }; + var beginShapeContactEvent = { + type: 'beginShapeContact', + bodyA: null, + bodyB: null, + shapeA: null, + shapeB: null + }; + var endShapeContactEvent = { + type: 'endShapeContact', + bodyA: null, + bodyB: null, + shapeA: null, + shapeB: null + }; + return function(){ + var hasBeginContact = this.hasAnyEventListener('beginContact'); + var hasEndContact = this.hasAnyEventListener('endContact'); + + if(hasBeginContact || hasEndContact){ + this.bodyOverlapKeeper.getDiff(additions, removals); + } + + if(hasBeginContact){ + for (var i = 0, l = additions.length; i < l; i += 2) { + beginContactEvent.bodyA = this.getBodyById(additions[i]); + beginContactEvent.bodyB = this.getBodyById(additions[i+1]); + this.dispatchEvent(beginContactEvent); + } + beginContactEvent.bodyA = beginContactEvent.bodyB = null; + } + + if(hasEndContact){ + for (var i = 0, l = removals.length; i < l; i += 2) { + endContactEvent.bodyA = this.getBodyById(removals[i]); + endContactEvent.bodyB = this.getBodyById(removals[i+1]); + this.dispatchEvent(endContactEvent); + } + endContactEvent.bodyA = endContactEvent.bodyB = null; + } + + additions.length = removals.length = 0; + + var hasBeginShapeContact = this.hasAnyEventListener('beginShapeContact'); + var hasEndShapeContact = this.hasAnyEventListener('endShapeContact'); + + if(hasBeginShapeContact || hasEndShapeContact){ + this.shapeOverlapKeeper.getDiff(additions, removals); + } + + if(hasBeginShapeContact){ + for (var i = 0, l = additions.length; i < l; i += 2) { + var shapeA = this.getShapeById(additions[i]); + var shapeB = this.getShapeById(additions[i+1]); + beginShapeContactEvent.shapeA = shapeA; + beginShapeContactEvent.shapeB = shapeB; + beginShapeContactEvent.bodyA = shapeA.body; + beginShapeContactEvent.bodyB = shapeB.body; + this.dispatchEvent(beginShapeContactEvent); + } + beginShapeContactEvent.bodyA = beginShapeContactEvent.bodyB = beginShapeContactEvent.shapeA = beginShapeContactEvent.shapeB = null; + } + + if(hasEndShapeContact){ + for (var i = 0, l = removals.length; i < l; i += 2) { + var shapeA = this.getShapeById(removals[i]); + var shapeB = this.getShapeById(removals[i+1]); + endShapeContactEvent.shapeA = shapeA; + endShapeContactEvent.shapeB = shapeB; + endShapeContactEvent.bodyA = shapeA.body; + endShapeContactEvent.bodyB = shapeB.body; + this.dispatchEvent(endShapeContactEvent); + } + endShapeContactEvent.bodyA = endShapeContactEvent.bodyB = endShapeContactEvent.shapeA = endShapeContactEvent.shapeB = null; + } + + }; +})(); + +/** + * Sets all body forces in the world to zero. + * @method clearForces + */ +World.prototype.clearForces = function(){ + var bodies = this.bodies; + var N = bodies.length; + for(var i=0; i !== N; i++){ + var b = bodies[i], + force = b.force, + tau = b.torque; + + b.force.set(0,0,0); + b.torque.set(0,0,0); + } +}; + +},{"../collision/AABB":3,"../collision/ArrayCollisionMatrix":4,"../collision/NaiveBroadphase":7,"../collision/OverlapKeeper":9,"../collision/Ray":10,"../collision/RaycastResult":11,"../equations/ContactEquation":20,"../equations/FrictionEquation":22,"../material/ContactMaterial":25,"../material/Material":26,"../math/Quaternion":29,"../math/Vec3":31,"../objects/Body":32,"../shapes/Shape":44,"../solver/GSSolver":47,"../utils/EventTarget":50,"../utils/TupleDictionary":53,"./Narrowphase":56}],58:[function(require,module,exports){ /** * Loads a Wavefront .mtl file specifying materials * @@ -535,7 +15063,7 @@ MTLLoader.MaterialCreator.prototype = { module.exports = MTLLoader; -},{"three":2}],2:[function(require,module,exports){ +},{"three":59}],59:[function(require,module,exports){ // File:src/Three.js /** @@ -42298,7 +56826,7 @@ THREE.MorphBlendMesh.prototype.update = function ( delta ) { }; -},{}],3:[function(require,module,exports){ +},{}],60:[function(require,module,exports){ 'use strict'; module.exports = function (THREE) { @@ -42952,7 +57480,7 @@ module.exports = function (THREE) { }; }; -},{}],4:[function(require,module,exports){ +},{}],61:[function(require,module,exports){ /** * @author mrdoob / http://mrdoob.com/ * Source: https://github.com/mrdoob/three.js/blob/master/examples/js/controls/PointerLockControls.js @@ -43139,7 +57667,7 @@ module.exports = function ( camera ) { }; }; -},{"three":5}],5:[function(require,module,exports){ +},{"three":62}],62:[function(require,module,exports){ (function (global, factory) { typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) : typeof define === 'function' && define.amd ? define(['exports'], factory) : @@ -87380,7 +101908,7 @@ module.exports = function ( camera ) { }))); -},{}],6:[function(require,module,exports){ +},{}],63:[function(require,module,exports){ 'use strict'; // const controls = require('./controls'); @@ -87396,7 +101924,9 @@ var start = function start(options) { renderer = options.renderer, objects = options.objects, raycaster = options.raycaster, - pointerLockControls = options.pointerLockControls; + pointerLockControls = options.pointerLockControls, + world = options.world, + timeStep = options.timeStep; // const keyboard = {}; // const player = { @@ -87412,7 +101942,8 @@ var start = function start(options) { if (!blocker.enabled) { var time = performance.now(); - letsMove(camera, scene, objects, raycaster, prevTime, time, pointerLockControls); + console.log(world); + letsMove(camera, scene, objects, raycaster, prevTime, time, pointerLockControls, world, timeStep); // // const player = pointLockers(); @@ -87431,7 +101962,7 @@ module.exports = { start: start }; -},{"./blocker":7,"./init/getRenderer":14,"./init/init":15,"./letsMove":16,"./pointLockers":17}],7:[function(require,module,exports){ +},{"./blocker":64,"./init/getRenderer":71,"./init/init":72,"./letsMove":73,"./pointLockers":74}],64:[function(require,module,exports){ 'use strict'; // sets up screen blocker (the darkened screen with instructions you see when you press esc) @@ -87480,7 +102011,7 @@ module.exports = function (controls) { module.exports.enabled = true; -},{}],8:[function(require,module,exports){ +},{}],65:[function(require,module,exports){ 'use strict'; var THREE = require('three'); @@ -87627,7 +102158,7 @@ module.exports = { // // module.exports = controls; -},{"./init/init":15,"three":5}],9:[function(require,module,exports){ +},{"./init/init":72,"three":62}],66:[function(require,module,exports){ 'use strict'; var THREE = require('three'); @@ -87648,7 +102179,7 @@ var getObj1 = function getObj1() { normalMap: crateNormalMap, wireframe: false })); - obj1.position.set(180, 35, 25); + obj1.position.set(180, 50, 25); obj1.receiveShadow = true; obj1.castShadow = true; return obj1; @@ -87747,7 +102278,7 @@ module.exports = { // // }) -},{"three":5,"three-mtl-loader":1,"three-obj-loader":3,"three-pointerlock":4}],10:[function(require,module,exports){ +},{"three":62,"three-mtl-loader":58,"three-obj-loader":60,"three-pointerlock":61}],67:[function(require,module,exports){ 'use strict'; var init = require('./init/init'); @@ -87755,7 +102286,7 @@ var animate = require('./animate'); animate.start(init()); -},{"./animate":6,"./init/init":15}],11:[function(require,module,exports){ +},{"./animate":63,"./init/init":72}],68:[function(require,module,exports){ "use strict"; var _scene = void 0; @@ -87768,7 +102299,7 @@ module.exports.init = function (scene) { _scene = scene; }; -},{}],12:[function(require,module,exports){ +},{}],69:[function(require,module,exports){ 'use strict'; var THREE = require('three'); @@ -87804,7 +102335,7 @@ var getFloor = function getFloor() { module.exports = getFloor; -},{"three":5}],13:[function(require,module,exports){ +},{"three":62}],70:[function(require,module,exports){ 'use strict'; var THREE = require('three'); @@ -87821,7 +102352,7 @@ var getLight = function getLight() { module.exports = getLight; -},{"three":5}],14:[function(require,module,exports){ +},{"three":62}],71:[function(require,module,exports){ 'use strict'; var THREE = require('three'); @@ -87837,10 +102368,11 @@ var getRenderer = function getRenderer() { module.exports = getRenderer; -},{"three":5}],15:[function(require,module,exports){ +},{"three":62}],72:[function(require,module,exports){ 'use strict'; var THREE = require('three'); +var CANNON = require('cannon'); var PointerLockControls = require('three-pointerlock'); var getScene = require('../getScene'); var pointerLocks = require('../pointLockers'); @@ -87876,6 +102408,24 @@ var bullet = function bullet() { // create the scene var init = function init() { + var timeStep = 1 / 60; + + // Cannon init + var world = new CANNON.World(); + world.gravity.set(0, -9.82, 0); + world.broadphase = new CANNON.NaiveBroadphase(); + world.solver.iterations = 10; + var shape = new CANNON.Box(new CANNON.Vec3(1, 1, 1)); + var mass = 1; + var body = new CANNON.Body({ + mass: 1 + }); + body.addShape(shape); + body.angularVelocity.set(0, 10, 0); + body.angularDamping = 0.5; + world.addBody(body); + console.log('this is my world', world); + // const camera = new THREE.PerspectiveCamera(75, -50, 1, 1000); var camera = new THREE.PerspectiveCamera(75, window.innerWidth / window.innerHeight, 1, 1000); //let's create the scene @@ -87901,7 +102451,7 @@ var init = function init() { scene.add(obj1, obj2, obj3, obj4, obj5); - //objects + // objects // const loader = new MTLLoader(); // loader.load('images/Oak_Green_01.mtl', function(materials) { // materials.preload(); @@ -87914,14 +102464,14 @@ var init = function init() { // // }) - //lighting + // lighting var ambientLight = new THREE.AmbientLight(0xffffff, 0.5); scene.add(ambientLight); var light = getLight(); scene.add(light); - //let's get the floor + // let's get the floor var floor = getFloor(); scene.add(floor); @@ -87937,22 +102487,25 @@ var init = function init() { camera.updateProjectionMatrix(); renderer.setSize(window.innerWidth, window.innerHeight); } - return { camera: camera, scene: scene, renderer: renderer, raycaster: raycaster, objects: objects, - pointerLockControls: pointerLockControls + pointerLockControls: pointerLockControls, + world: world, + timeStep: timeStep }; }; module.exports = init; -},{"../blocker":7,"../controls":8,"../cubes":9,"../getScene":11,"../letsMove":16,"../pointLockers":17,"./getFloor":12,"./getLight":13,"./getRenderer":14,"three":5,"three-pointerlock":4}],16:[function(require,module,exports){ +},{"../blocker":64,"../controls":65,"../cubes":66,"../getScene":68,"../letsMove":73,"../pointLockers":74,"./getFloor":69,"./getLight":70,"./getRenderer":71,"cannon":2,"three":62,"three-pointerlock":61}],73:[function(require,module,exports){ 'use strict'; +var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; + var THREE = require('three'); var pointLockers = require('./pointLockers'); @@ -87964,7 +102517,13 @@ var _require = require('./controls'), var bullets = []; var velocity = new THREE.Vector3(); -module.exports = function (camera, scene, objects, raycaster, prevTime, time, pointerLockControls) { +module.exports = function (camera, scene, objects, raycaster, prevTime, time, pointerLockControls, world, timeStep) { + + console.log(typeof world === 'undefined' ? 'undefined' : _typeof(world)); + console.log(world); + world.step(timeStep); + objects.obj1.Mesh.position.copy(world.body.position); + objects.obj1.Mesh.quaternion.copy(world.body.quaternion); raycaster.ray.origin.copy(pointLockers().position); raycaster.ray.origin.y -= 10; @@ -88047,7 +102606,7 @@ var stopIfSlow = function stopIfSlow(velocity) { return Math.abs(velocity) < 0.1 ? 0 : velocity; }; -},{"./controls":8,"./pointLockers":17,"three":5}],17:[function(require,module,exports){ +},{"./controls":65,"./pointLockers":74,"three":62}],74:[function(require,module,exports){ "use strict"; var _pointerLockControls = void 0; @@ -88060,4 +102619,4 @@ module.exports.init = function (pointerLockControls) { _pointerLockControls = pointerLockControls; }; -},{}]},{},[10]); +},{}]},{},[67]); diff --git a/src/animate.js b/src/animate.js index 39f2502..572c861 100644 --- a/src/animate.js +++ b/src/animate.js @@ -12,7 +12,9 @@ const start = (options) => { renderer, objects, raycaster, - pointerLockControls + pointerLockControls, + world, + timeStep, } = options; // const keyboard = {}; @@ -28,7 +30,8 @@ const start = (options) => { if (!blocker.enabled) { const time = performance.now(); - letsMove(camera,scene,objects, raycaster, prevTime, time, pointerLockControls); + console.log(world); + letsMove(camera,scene,objects, raycaster, prevTime, time, pointerLockControls, world, timeStep); // // const player = pointLockers(); diff --git a/src/cubes.js b/src/cubes.js index 76efccd..e2fdfc1 100644 --- a/src/cubes.js +++ b/src/cubes.js @@ -17,10 +17,10 @@ const getObj1 = () => { map: crateTexture, bumpMap: crateBumpMap, normalMap: crateNormalMap, - wireframe: false - }) + wireframe: false, + }), ); - obj1.position.set(180, 35, 25); + obj1.position.set(180, 50, 25); obj1.receiveShadow = true; obj1.castShadow = true; return obj1; diff --git a/src/init/init.js b/src/init/init.js index 169df48..059e7a7 100644 --- a/src/init/init.js +++ b/src/init/init.js @@ -1,4 +1,5 @@ const THREE = require('three'); +const CANNON = require('cannon'); const PointerLockControls = require('three-pointerlock'); const getScene = require('../getScene'); const pointerLocks = require('../pointLockers'); @@ -22,20 +23,39 @@ const blocker = require('../blocker'); // }; const bullet = () => { -var bullet = new THREE.Mesh( - new THREE.SphereGeometry(5, 8, 8), - new THREE.MeshBasicMaterial()); + const bullet = new THREE.Mesh( + new THREE.SphereGeometry(5, 8, 8), + new THREE.MeshBasicMaterial(), + ); bullet.alive = true; - setTimeout(function() { + setTimeout(function () { bullet.alive = false; scene.remove(bullet); }, 1000); scene.add(bullet); -} +}; // create the scene const init = () => { + const timeStep = 1 / 60; + + // Cannon init +const world = new CANNON.World(); + world.gravity.set(0,-9.82,0); + world.broadphase = new CANNON.NaiveBroadphase(); + world.solver.iterations = 10; + const shape = new CANNON.Box(new CANNON.Vec3(1,1,1)); + const mass = 1; + const body = new CANNON.Body({ + mass: 1 + }); + body.addShape(shape); + body.angularVelocity.set(0,10,0); + body.angularDamping = 0.5; + world.addBody(body); + console.log('this is my world', world); + // const camera = new THREE.PerspectiveCamera(75, -50, 1, 1000); const camera = new THREE.PerspectiveCamera(75, window.innerWidth / window.innerHeight, 1, 1000); //let's create the scene @@ -62,8 +82,7 @@ const init = () => { scene.add(obj1, obj2, obj3, obj4, obj5); - - //objects + // objects // const loader = new MTLLoader(); // loader.load('images/Oak_Green_01.mtl', function(materials) { // materials.preload(); @@ -76,14 +95,14 @@ const init = () => { // // }) - //lighting + // lighting const ambientLight = new THREE.AmbientLight(0xffffff, 0.5); scene.add(ambientLight); const light = getLight(); scene.add(light); - //let's get the floor + // let's get the floor const floor = getFloor(); scene.add(floor); @@ -100,16 +119,17 @@ const init = () => { camera.updateProjectionMatrix(); renderer.setSize(window.innerWidth, window.innerHeight); } - return { camera, scene, renderer, raycaster, objects, - pointerLockControls + pointerLockControls, + world, + timeStep, }; -} +}; module.exports = init; diff --git a/src/letsMove.js b/src/letsMove.js index f89ebb5..3efcd92 100644 --- a/src/letsMove.js +++ b/src/letsMove.js @@ -8,7 +8,14 @@ const {movements} = require('./controls'); let bullets = [] ; const velocity = new THREE.Vector3(); -module.exports = function(camera,scene,objects, raycaster, prevTime, time, pointerLockControls){ +module.exports = function(camera,scene,objects, raycaster, prevTime, time, pointerLockControls, world, timeStep){ + +console.log(typeof world); +console.log(world); + world.step(timeStep); + objects.obj1.Mesh.position.copy(world.body.position); + objects.obj1.Mesh.quaternion.copy(world.body.quaternion); + raycaster.ray.origin.copy(pointLockers().position); raycaster.ray.origin.y -= 10; From 72c3daa60edfd438745469649fc9a56dad41cef9 Mon Sep 17 00:00:00 2001 From: RogeredBacon Date: Thu, 7 Sep 2017 16:37:11 +0000 Subject: [PATCH 2/9] Tidyed up the code with beautify and eslint-airbnb --- public/index.html | 60 +++++++++++++---------- public/js/bundle.js | 28 ++++++----- src/animate.js | 27 +++++----- src/blocker.js | 16 +++--- src/controls.js | 14 +++--- src/cubes.js | 78 +++++++++++++++-------------- src/init/getFloor.js | 4 +- src/init/init.js | 36 +++++++------- src/letsMove.js | 114 ++++++++++++++++++++++--------------------- src/pointLockers.js | 1 - src/shoot.js | 14 +++--- 11 files changed, 203 insertions(+), 189 deletions(-) diff --git a/public/index.html b/public/index.html index 05175b0..65cb611 100644 --- a/public/index.html +++ b/public/index.html @@ -1,29 +1,39 @@ - - - GD - - - + + + + + GD + + + + + - - - -
- -
- Click to play -
- (W, A, S, D = Move, SPACE = Jump, MOUSE = Look around) -
- -
- - - - + + +
+ +
+ Click to play +
(W, A, S, D = Move, SPACE = Jump, MOUSE = Look around) +
+ +
+ + + + + diff --git a/public/js/bundle.js b/public/js/bundle.js index 33c4c3a..8ffafb8 100644 --- a/public/js/bundle.js +++ b/public/js/bundle.js @@ -102504,8 +102504,6 @@ module.exports = init; },{"../blocker":64,"../controls":65,"../cubes":66,"../getScene":68,"../letsMove":73,"../pointLockers":74,"./getFloor":69,"./getLight":70,"./getRenderer":71,"cannon":2,"three":62,"three-pointerlock":61}],73:[function(require,module,exports){ 'use strict'; -var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; - var THREE = require('three'); var pointLockers = require('./pointLockers'); @@ -102518,12 +102516,11 @@ var bullets = []; var velocity = new THREE.Vector3(); module.exports = function (camera, scene, objects, raycaster, prevTime, time, pointerLockControls, world, timeStep) { - - console.log(typeof world === 'undefined' ? 'undefined' : _typeof(world)); - console.log(world); + console.log(objects); world.step(timeStep); - objects.obj1.Mesh.position.copy(world.body.position); - objects.obj1.Mesh.quaternion.copy(world.body.quaternion); + // objects.obj1.Mesh.position.copy(world.body.position); + // objects.obj1.Mesh.quaternion.copy(world.body.quaternion); + raycaster.ray.origin.copy(pointLockers().position); raycaster.ray.origin.y -= 10; @@ -102550,7 +102547,6 @@ module.exports = function (camera, scene, objects, raycaster, prevTime, time, po var bullet = new THREE.Mesh(new THREE.SphereGeometry(0.5, 8, 8), new THREE.MeshBasicMaterial()); bullet.position.set(raycaster.ray.origin.x, raycaster.ray.origin.y, raycaster.ray.origin.z); - console.log('pointlocker', pointerLockControls.getObject()); bullet.velocity = new THREE.Vector3(-Math.sin(pointerLockControls.getObject().rotation._y), 0, -Math.cos(pointerLockControls.getObject().rotation._y)); bullet.alive = true; @@ -102562,13 +102558,21 @@ module.exports = function (camera, scene, objects, raycaster, prevTime, time, po scene.add(bullet); } - if (movements.forward) velocity.z -= 2000.0 * delta; + if (movements.forward) { + velocity.z -= 2000.0 * delta; + } - if (movements.backward) velocity.z += 1000.0 * delta; + if (movements.backward) { + velocity.z += 1000.0 * delta; + } - if (movements.left) velocity.x -= 1000.0 * delta; + if (movements.left) { + velocity.x -= 1000.0 * delta; + } - if (movements.right) velocity.x += 1000.0 * delta; + if (movements.right) { + velocity.x += 1000.0 * delta; + } if (isOnObject === true) { velocity.y = Math.max(0, velocity.y); diff --git a/src/animate.js b/src/animate.js index 572c861..6a1cc24 100644 --- a/src/animate.js +++ b/src/animate.js @@ -1,8 +1,8 @@ // const controls = require('./controls'); -const init = require('./init/init'); -const getRenderer = require('./init/getRenderer'); +// const init = require('./init/init'); +// const getRenderer = require('./init/getRenderer'); const letsMove = require('./letsMove'); -const pointLockers = require('./pointLockers'); +// const pointLockers = require('./pointLockers'); const blocker = require('./blocker'); const start = (options) => { @@ -28,11 +28,18 @@ const start = (options) => { const animate = () => { requestAnimationFrame(animate); if (!blocker.enabled) { - const time = performance.now(); - console.log(world); - letsMove(camera,scene,objects, raycaster, prevTime, time, pointerLockControls, world, timeStep); - // + letsMove( + camera, + scene, + objects, + raycaster, + prevTime, + time, + pointerLockControls, + world, + timeStep, + ); // const player = pointLockers(); prevTime = time; @@ -40,15 +47,13 @@ const start = (options) => { // mesh.rotation.x += 0.1; // mesh.rotation.y += 0.1; - //controls(keyboard, camera, player); + // controls(keyboard, camera, player); renderer.render(scene, camera); - }; animate(); - }; module.exports = { - start + start, }; diff --git a/src/blocker.js b/src/blocker.js index bd4a7e6..8dcbc9c 100644 --- a/src/blocker.js +++ b/src/blocker.js @@ -1,15 +1,15 @@ // sets up screen blocker (the darkened screen with instructions you see when you press esc) -module.exports = function(controls){ - var blocker = document.getElementById('blocker'); - var instructions = document.getElementById('instructions'); +module.exports = function (controls) { + const blocker = document.getElementById('blocker'); + const instructions = document.getElementById('instructions'); // http://www.html5rocks.com/en/tutorials/pointerlock/intro/ - var havePointerLock = ('pointerLockElement' in document) + const havePointerLock = ('pointerLockElement' in document) || ('mozPointerLockElement' in document) || ('webkitPointerLockElement' in document); if (havePointerLock) { - var element = document.body; - var pointerlockchange = function() { + const element = document.body; + const pointerlockchange = function () { if (document.pointerLockElement === element || document.mozPointerLockElement === element || document.webkitPointerLockElement === element) { @@ -24,7 +24,7 @@ module.exports = function(controls){ instructions.style.display = ''; } }; - var pointerlockerror = function() { + const pointerlockerror = function () { instructions.style.display = ''; }; // Hook pointer lock state change events @@ -35,7 +35,7 @@ module.exports = function(controls){ document.addEventListener('mozpointerlockerror', pointerlockerror, false); document.addEventListener('webkitpointerlockerror', pointerlockerror, false); - instructions.addEventListener('click', function() { + instructions.addEventListener('click', () => { instructions.style.display = 'none'; // Ask the browser to lock the pointer element.requestPointerLock = element.requestPointerLock diff --git a/src/controls.js b/src/controls.js index 58ce25f..c24fa9a 100644 --- a/src/controls.js +++ b/src/controls.js @@ -1,5 +1,5 @@ const THREE = require('three'); -//const init = require('./init/init'); +// const init = require('./init/init'); const bullet = require('./init/init'); const init = () => { @@ -51,18 +51,16 @@ const init = () => { movements.right = false; break; case 17: - console.log('ctrl working up'); movements.shooting = false; break; } }; - //document.addEventListener( 'mousemove', onMouseMove, false ); + // document.addEventListener( 'mousemove', onMouseMove, false ); document.addEventListener('keydown', onKeyDown, false); document.addEventListener('keyup', onKeyUp, false); // document.addEventListener('click', shoot, false); - -} +}; const movements = { forward: false, backward: false, @@ -70,11 +68,11 @@ const movements = { right: false, jumping: false, canJump: true, - shooting: false + shooting: false, }; module.exports = { init, - movements + movements, }; @@ -126,7 +124,7 @@ module.exports = { // keyboard[event.keyCode] = false; // } -//document.addEventListener('mousemove', mouseMove, false); +// document.addEventListener('mousemove', mouseMove, false); // document.addEventListener('keydown', keyDown, false); // document.addEventListener('keyup', keyUp, false); // diff --git a/src/cubes.js b/src/cubes.js index e2fdfc1..6f9f3be 100644 --- a/src/cubes.js +++ b/src/cubes.js @@ -1,15 +1,16 @@ const THREE = require('three'); const PointerLockControls = require('three-pointerlock'); const OBJLoader = require('three-obj-loader'); + OBJLoader(THREE); const MTLLoader = require('three-mtl-loader'); const getObj1 = () => { const textureLoader = new THREE.TextureLoader(); - const crateTexture = textureLoader.load("images/crate/crate0_diffuse.png"); - const crateBumpMap = textureLoader.load("images/crate/crate0_bump.png"); - const crateNormalMap = textureLoader.load("images/crate/crate0_normal.png"); + const crateTexture = textureLoader.load('images/crate/crate0_diffuse.png'); + const crateBumpMap = textureLoader.load('images/crate/crate0_bump.png'); + const crateNormalMap = textureLoader.load('images/crate/crate0_normal.png'); const obj1 = new THREE.Mesh( new THREE.BoxGeometry(40, 40, 40), new THREE.MeshPhongMaterial({ @@ -28,9 +29,9 @@ const getObj1 = () => { const getObj2 = () => { const textureLoader = new THREE.TextureLoader(); - const crateTexture = textureLoader.load("images/crate/crate0_diffuse.png"); - const crateBumpMap = textureLoader.load("images/crate/crate0_bump.png"); - const crateNormalMap = textureLoader.load("images/crate/crate0_normal.png"); + const crateTexture = textureLoader.load('images/crate/crate0_diffuse.png'); + const crateBumpMap = textureLoader.load('images/crate/crate0_bump.png'); + const crateNormalMap = textureLoader.load('images/crate/crate0_normal.png'); const obj2 = new THREE.Mesh( new THREE.BoxGeometry(40, 40, 40), new THREE.MeshPhongMaterial({ @@ -38,8 +39,8 @@ const getObj2 = () => { map: crateTexture, bumpMap: crateBumpMap, normalMap: crateNormalMap, - wireframe: false - }) + wireframe: false, + }), ); obj2.position.set(200, -5, 25); obj2.receiveShadow = true; @@ -50,9 +51,9 @@ const getObj2 = () => { const getObj3 = () => { const textureLoader = new THREE.TextureLoader(); - const crateTexture = textureLoader.load("images/crate/crate0_diffuse.png"); - const crateBumpMap = textureLoader.load("images/crate/crate0_bump.png"); - const crateNormalMap = textureLoader.load("images/crate/crate0_normal.png"); + const crateTexture = textureLoader.load('images/crate/crate0_diffuse.png'); + const crateBumpMap = textureLoader.load('images/crate/crate0_bump.png'); + const crateNormalMap = textureLoader.load('images/crate/crate0_normal.png'); const obj3 = new THREE.Mesh( new THREE.BoxGeometry(40, 40, 40), new THREE.MeshPhongMaterial({ @@ -60,8 +61,8 @@ const getObj3 = () => { map: crateTexture, bumpMap: crateBumpMap, normalMap: crateNormalMap, - wireframe: false - }) + wireframe: false, + }), ); obj3.position.set(160, -5, 25); obj3.receiveShadow = true; @@ -71,9 +72,9 @@ const getObj3 = () => { const getObj4 = () => { const textureLoader = new THREE.TextureLoader(); - const crateTexture = textureLoader.load("images/crate/crate0_diffuse.png"); - const crateBumpMap = textureLoader.load("images/crate/crate0_bump.png"); - const crateNormalMap = textureLoader.load("images/crate/crate0_normal.png"); + const crateTexture = textureLoader.load('images/crate/crate0_diffuse.png'); + const crateBumpMap = textureLoader.load('images/crate/crate0_bump.png'); + const crateNormalMap = textureLoader.load('images/crate/crate0_normal.png'); const obj4 = new THREE.Mesh( new THREE.BoxGeometry(40, 40, 40), new THREE.MeshPhongMaterial({ @@ -81,20 +82,19 @@ const getObj4 = () => { map: crateTexture, bumpMap: crateBumpMap, normalMap: crateNormalMap, - wireframe: false - }) + wireframe: false, + }), ); obj4.position.set(50, -5, 25); obj4.receiveShadow = true; obj4.castShadow = true; return obj4; - }; const getObj5 = () => { const textureLoader = new THREE.TextureLoader(); - const crateTexture = textureLoader.load("images/crate/crate0_diffuse.png"); - const crateBumpMap = textureLoader.load("images/crate/crate0_bump.png"); - const crateNormalMap = textureLoader.load("images/crate/crate0_normal.png"); + const crateTexture = textureLoader.load('images/crate/crate0_diffuse.png'); + const crateBumpMap = textureLoader.load('images/crate/crate0_bump.png'); + const crateNormalMap = textureLoader.load('images/crate/crate0_normal.png'); const obj5 = new THREE.Mesh( new THREE.BoxGeometry(40, 40, 40), new THREE.MeshPhongMaterial({ @@ -102,36 +102,34 @@ const getObj5 = () => { map: crateTexture, bumpMap: crateBumpMap, normalMap: crateNormalMap, - wireframe: false - }) + wireframe: false, + }), ); obj5.position.set(10, -5, 25); obj5.receiveShadow = true; obj5.castShadow = true; return obj5; -} +}; module.exports = { getObj1, getObj2, getObj3, getObj4, - getObj5 + getObj5, }; - - -//objects - // const loader = new MTLLoader(); - // loader.load('images/Oak_Green_01.mtl', function(materials) { - // materials.preload(); - // const objLoader = new THREE.OBJLoader(); - // objLoader.setMaterials(materials); - // - // objLoader.load('images/Oak_Green_01.obj', function(tree) { - // scene.add(tree) - // }) - // - // }) +// objects +// const loader = new MTLLoader(); +// loader.load('images/Oak_Green_01.mtl', function(materials) { +// materials.preload(); +// const objLoader = new THREE.OBJLoader(); +// objLoader.setMaterials(materials); +// +// objLoader.load('images/Oak_Green_01.obj', function(tree) { +// scene.add(tree) +// }) +// +// }) diff --git a/src/init/getFloor.js b/src/init/getFloor.js index 9e27aa5..b7e7f64 100644 --- a/src/init/getFloor.js +++ b/src/init/getFloor.js @@ -9,7 +9,7 @@ const getFloor = () => { floorTexture.repeat.set(50, 50); const geometry = new THREE.PlaneBufferGeometry(2500, 2500, 5, 5); geometry.applyMatrix(new THREE.Matrix4().makeRotationX(-Math.PI / 2)); - const material = new THREE.MeshLambertMaterial({map: floorTexture}); + const material = new THREE.MeshLambertMaterial({ map: floorTexture }); const floor = new THREE.Mesh(geometry, material); floor.position.y = -25; @@ -30,6 +30,4 @@ const getFloor = () => { }; - - module.exports = getFloor; diff --git a/src/init/init.js b/src/init/init.js index 059e7a7..637f9fe 100644 --- a/src/init/init.js +++ b/src/init/init.js @@ -3,7 +3,6 @@ const CANNON = require('cannon'); const PointerLockControls = require('three-pointerlock'); const getScene = require('../getScene'); const pointerLocks = require('../pointLockers'); -const letsMove = require('../letsMove'); const controls = require('../controls'); const getRenderer = require('./getRenderer'); const getLight = require('./getLight'); @@ -28,7 +27,7 @@ const bullet = () => { new THREE.MeshBasicMaterial(), ); bullet.alive = true; - setTimeout(function () { + setTimeout(() => { bullet.alive = false; scene.remove(bullet); }, 1000); @@ -41,28 +40,26 @@ const init = () => { const timeStep = 1 / 60; // Cannon init -const world = new CANNON.World(); - world.gravity.set(0,-9.82,0); - world.broadphase = new CANNON.NaiveBroadphase(); - world.solver.iterations = 10; - const shape = new CANNON.Box(new CANNON.Vec3(1,1,1)); - const mass = 1; - const body = new CANNON.Body({ - mass: 1 - }); - body.addShape(shape); - body.angularVelocity.set(0,10,0); - body.angularDamping = 0.5; - world.addBody(body); - console.log('this is my world', world); + const world = new CANNON.World(); + world.gravity.set(0, -9.82, 0); + world.broadphase = new CANNON.NaiveBroadphase(); + world.solver.iterations = 10; + const shape = new CANNON.Box(new CANNON.Vec3(1, 1, 1)); + const body = new CANNON.Body({ + mass: 1, + }); + body.addShape(shape); + body.angularVelocity.set(0, 10, 0); + body.angularDamping = 0.5; + world.addBody(body); // const camera = new THREE.PerspectiveCamera(75, -50, 1, 1000); const camera = new THREE.PerspectiveCamera(75, window.innerWidth / window.innerHeight, 1, 1000); - //let's create the scene + // let's create the scene const scene = new THREE.Scene(); - //and our camera + // and our camera - //camera.position.set(0, 0, -5); + // camera.position.set(0, 0, -5); // camera.lookAt(0, 500, 0); // direction camera is looking getScene.init(scene); const pointerLockControls = new PointerLockControls(camera); @@ -119,6 +116,7 @@ const world = new CANNON.World(); camera.updateProjectionMatrix(); renderer.setSize(window.innerWidth, window.innerHeight); } + console.log(objects); return { camera, scene, diff --git a/src/letsMove.js b/src/letsMove.js index 3efcd92..010b55d 100644 --- a/src/letsMove.js +++ b/src/letsMove.js @@ -3,18 +3,27 @@ const pointLockers = require('./pointLockers'); // const shoot = require('./shoot.js'); -const {movements} = require('./controls'); +const { + movements, +} = require('./controls'); -let bullets = [] ; +const bullets = []; const velocity = new THREE.Vector3(); -module.exports = function(camera,scene,objects, raycaster, prevTime, time, pointerLockControls, world, timeStep){ - -console.log(typeof world); -console.log(world); +module.exports = function ( + camera, + scene, + objects, + raycaster, + prevTime, + time, + pointerLockControls, + world, + timeStep, +) { world.step(timeStep); - objects.obj1.Mesh.position.copy(world.body.position); - objects.obj1.Mesh.quaternion.copy(world.body.quaternion); + // objects.obj1.Mesh.position.copy(world.body.position); + // objects.obj1.Mesh.quaternion.copy(world.body.quaternion); raycaster.ray.origin.copy(pointLockers().position); @@ -26,57 +35,52 @@ console.log(world); velocity.z -= velocity.z * 10.0 * delta; velocity.y -= 9.8 * 100.0 * delta; // 100.0 = mass -for (var index= 0; index < bullets.length ; index++) { - if (bullets[index] === undefined) { - continue; - } - if (bullets[index].alive == false) { - bullets.splice(index,1); - continue; + for (let index = 0; index < bullets.length; index++) { + if (bullets[index] === undefined) { + continue; + } + if (bullets[index].alive == false) { + bullets.splice(index, 1); + continue; + } + bullets[index].position.add(bullets[index].velocity); } - bullets[index].position.add(bullets[index].velocity); -} - if (movements.shooting){ + if (movements.shooting) { // shoot.bullet(scene); - var bullet = new THREE.Mesh( + const bullet = new THREE.Mesh( new THREE.SphereGeometry(0.5, 8, 8), - new THREE.MeshBasicMaterial()); - - bullet.position.set( - raycaster.ray.origin.x, - raycaster.ray.origin.y, - raycaster.ray.origin.z - ); -console.log('pointlocker', pointerLockControls.getObject()); - bullet.velocity = new THREE.Vector3( - -Math.sin(pointerLockControls.getObject().rotation._y), - 0, - -Math.cos(pointerLockControls.getObject().rotation._y), - - - ); - - bullet.alive = true; - setTimeout(function() { - bullet.alive = false; - scene.remove(bullet); - }, 1000); - bullets.push(bullet); - scene.add(bullet); + new THREE.MeshBasicMaterial(), + ); + + bullet.position.set( + raycaster.ray.origin.x, + raycaster.ray.origin.y, + raycaster.ray.origin.z, + ); + bullet.velocity = new THREE.Vector3( + -Math.sin(pointerLockControls.getObject().rotation._y), + 0, -Math.cos(pointerLockControls.getObject().rotation._y), + + + ); + + bullet.alive = true; + setTimeout(() => { + bullet.alive = false; + scene.remove(bullet); + }, 1000); + bullets.push(bullet); + scene.add(bullet); } - if (movements.forward) - velocity.z -= 2000.0 * delta; + if (movements.forward) { velocity.z -= 2000.0 * delta; } - if (movements.backward) - velocity.z += 1000.0 * delta; + if (movements.backward) { velocity.z += 1000.0 * delta; } - if (movements.left) - velocity.x -= 1000.0 * delta; + if (movements.left) { velocity.x -= 1000.0 * delta; } - if (movements.right) - velocity.x += 1000.0 * delta; + if (movements.right) { velocity.x += 1000.0 * delta; } if (isOnObject === true) { velocity.y = Math.max(0, velocity.y); @@ -88,7 +92,7 @@ console.log('pointlocker', pointerLockControls.getObject()); } } - if (movements.jumping){ + if (movements.jumping) { velocity.y = 350; movements.jumping = false; movements.canJump = false; @@ -110,7 +114,7 @@ console.log('pointlocker', pointerLockControls.getObject()); // this is to stop lots of tiny movements from being sent to server once // player has stopped moving but continues to slightly slide -const stopIfSlow = (velocity) => - Math.abs(velocity) < 0.1 - ? 0 - : velocity; +const stopIfSlow = velocity => + (Math.abs(velocity) < 0.1 ? + 0 : + velocity); diff --git a/src/pointLockers.js b/src/pointLockers.js index fc0dc4d..61a1139 100644 --- a/src/pointLockers.js +++ b/src/pointLockers.js @@ -5,5 +5,4 @@ module.exports = () => module.exports.init = (pointerLockControls) => { _pointerLockControls = pointerLockControls; - }; diff --git a/src/shoot.js b/src/shoot.js index 23ac07b..777a726 100644 --- a/src/shoot.js +++ b/src/shoot.js @@ -1,19 +1,19 @@ // try to call this functions from letsMove later...a const bullet = (scene) => { -var bullet = new THREE.Mesh( - new THREE.SphereGeometry(0.5, 8, 8), - new THREE.MeshBasicMaterial()); + const bullet = new THREE.Mesh( + new THREE.SphereGeometry(0.5, 8, 8), + new THREE.MeshBasicMaterial(), + ); -bullet.position.set(player.position.x,player.position.y,player.position.z); + bullet.position.set(player.position.x, player.position.y, player.position.z); bullet.alive = true; - setTimeout(function() { + setTimeout(() => { bullet.alive = false; scene.remove(bullet); }, 1000); scene.add(bullet); -} - +}; module.exports = bullet; From 56dc73ca4f43148944c948fa92d265f2f1a0af23 Mon Sep 17 00:00:00 2001 From: RogeredBacon Date: Thu, 7 Sep 2017 18:05:40 +0000 Subject: [PATCH 3/9] Sucessfully added the physics engine(check out the spinning crate!) Started adding physics to bullets but stopped due to extreme tiredness #5 --- public/js/bundle.js | 89 ++++++++++++++++++++++++--------------------- src/init/init.js | 6 +-- src/letsMove.js | 18 ++++++++- 3 files changed, 67 insertions(+), 46 deletions(-) diff --git a/public/js/bundle.js b/public/js/bundle.js index 8ffafb8..29fe0e0 100644 --- a/public/js/bundle.js +++ b/public/js/bundle.js @@ -101912,10 +101912,10 @@ module.exports = function ( camera ) { 'use strict'; // const controls = require('./controls'); -var init = require('./init/init'); -var getRenderer = require('./init/getRenderer'); +// const init = require('./init/init'); +// const getRenderer = require('./init/getRenderer'); var letsMove = require('./letsMove'); -var pointLockers = require('./pointLockers'); +// const pointLockers = require('./pointLockers'); var blocker = require('./blocker'); var start = function start(options) { @@ -101940,11 +101940,8 @@ var start = function start(options) { var animate = function animate() { requestAnimationFrame(animate); if (!blocker.enabled) { - var time = performance.now(); - console.log(world); letsMove(camera, scene, objects, raycaster, prevTime, time, pointerLockControls, world, timeStep); - // // const player = pointLockers(); prevTime = time; @@ -101952,7 +101949,7 @@ var start = function start(options) { // mesh.rotation.x += 0.1; // mesh.rotation.y += 0.1; - //controls(keyboard, camera, player); + // controls(keyboard, camera, player); renderer.render(scene, camera); }; animate(); @@ -101962,7 +101959,7 @@ module.exports = { start: start }; -},{"./blocker":64,"./init/getRenderer":71,"./init/init":72,"./letsMove":73,"./pointLockers":74}],64:[function(require,module,exports){ +},{"./blocker":64,"./letsMove":73}],64:[function(require,module,exports){ 'use strict'; // sets up screen blocker (the darkened screen with instructions you see when you press esc) @@ -102015,7 +102012,7 @@ module.exports.enabled = true; 'use strict'; var THREE = require('three'); -//const init = require('./init/init'); +// const init = require('./init/init'); var bullet = require('./init/init'); var init = function init() { @@ -102076,13 +102073,12 @@ var init = function init() { movements.right = false; break; case 17: - console.log('ctrl working up'); movements.shooting = false; break; } }; - //document.addEventListener( 'mousemove', onMouseMove, false ); + // document.addEventListener( 'mousemove', onMouseMove, false ); document.addEventListener('keydown', onKeyDown, false); document.addEventListener('keyup', onKeyUp, false); // document.addEventListener('click', shoot, false); @@ -102149,7 +102145,7 @@ module.exports = { // keyboard[event.keyCode] = false; // } -//document.addEventListener('mousemove', mouseMove, false); +// document.addEventListener('mousemove', mouseMove, false); // document.addEventListener('keydown', keyDown, false); // document.addEventListener('keyup', keyUp, false); // @@ -102164,14 +102160,15 @@ module.exports = { var THREE = require('three'); var PointerLockControls = require('three-pointerlock'); var OBJLoader = require('three-obj-loader'); + OBJLoader(THREE); var MTLLoader = require('three-mtl-loader'); var getObj1 = function getObj1() { var textureLoader = new THREE.TextureLoader(); - var crateTexture = textureLoader.load("images/crate/crate0_diffuse.png"); - var crateBumpMap = textureLoader.load("images/crate/crate0_bump.png"); - var crateNormalMap = textureLoader.load("images/crate/crate0_normal.png"); + var crateTexture = textureLoader.load('images/crate/crate0_diffuse.png'); + var crateBumpMap = textureLoader.load('images/crate/crate0_bump.png'); + var crateNormalMap = textureLoader.load('images/crate/crate0_normal.png'); var obj1 = new THREE.Mesh(new THREE.BoxGeometry(40, 40, 40), new THREE.MeshPhongMaterial({ color: 0xffffff, map: crateTexture, @@ -102187,9 +102184,9 @@ var getObj1 = function getObj1() { var getObj2 = function getObj2() { var textureLoader = new THREE.TextureLoader(); - var crateTexture = textureLoader.load("images/crate/crate0_diffuse.png"); - var crateBumpMap = textureLoader.load("images/crate/crate0_bump.png"); - var crateNormalMap = textureLoader.load("images/crate/crate0_normal.png"); + var crateTexture = textureLoader.load('images/crate/crate0_diffuse.png'); + var crateBumpMap = textureLoader.load('images/crate/crate0_bump.png'); + var crateNormalMap = textureLoader.load('images/crate/crate0_normal.png'); var obj2 = new THREE.Mesh(new THREE.BoxGeometry(40, 40, 40), new THREE.MeshPhongMaterial({ color: 0xffffff, map: crateTexture, @@ -102205,9 +102202,9 @@ var getObj2 = function getObj2() { var getObj3 = function getObj3() { var textureLoader = new THREE.TextureLoader(); - var crateTexture = textureLoader.load("images/crate/crate0_diffuse.png"); - var crateBumpMap = textureLoader.load("images/crate/crate0_bump.png"); - var crateNormalMap = textureLoader.load("images/crate/crate0_normal.png"); + var crateTexture = textureLoader.load('images/crate/crate0_diffuse.png'); + var crateBumpMap = textureLoader.load('images/crate/crate0_bump.png'); + var crateNormalMap = textureLoader.load('images/crate/crate0_normal.png'); var obj3 = new THREE.Mesh(new THREE.BoxGeometry(40, 40, 40), new THREE.MeshPhongMaterial({ color: 0xffffff, map: crateTexture, @@ -102223,9 +102220,9 @@ var getObj3 = function getObj3() { var getObj4 = function getObj4() { var textureLoader = new THREE.TextureLoader(); - var crateTexture = textureLoader.load("images/crate/crate0_diffuse.png"); - var crateBumpMap = textureLoader.load("images/crate/crate0_bump.png"); - var crateNormalMap = textureLoader.load("images/crate/crate0_normal.png"); + var crateTexture = textureLoader.load('images/crate/crate0_diffuse.png'); + var crateBumpMap = textureLoader.load('images/crate/crate0_bump.png'); + var crateNormalMap = textureLoader.load('images/crate/crate0_normal.png'); var obj4 = new THREE.Mesh(new THREE.BoxGeometry(40, 40, 40), new THREE.MeshPhongMaterial({ color: 0xffffff, map: crateTexture, @@ -102240,9 +102237,9 @@ var getObj4 = function getObj4() { }; var getObj5 = function getObj5() { var textureLoader = new THREE.TextureLoader(); - var crateTexture = textureLoader.load("images/crate/crate0_diffuse.png"); - var crateBumpMap = textureLoader.load("images/crate/crate0_bump.png"); - var crateNormalMap = textureLoader.load("images/crate/crate0_normal.png"); + var crateTexture = textureLoader.load('images/crate/crate0_diffuse.png'); + var crateBumpMap = textureLoader.load('images/crate/crate0_bump.png'); + var crateNormalMap = textureLoader.load('images/crate/crate0_normal.png'); var obj5 = new THREE.Mesh(new THREE.BoxGeometry(40, 40, 40), new THREE.MeshPhongMaterial({ color: 0xffffff, map: crateTexture, @@ -102265,7 +102262,7 @@ module.exports = { getObj5: getObj5 }; -//objects +// objects // const loader = new MTLLoader(); // loader.load('images/Oak_Green_01.mtl', function(materials) { // materials.preload(); @@ -102376,7 +102373,6 @@ var CANNON = require('cannon'); var PointerLockControls = require('three-pointerlock'); var getScene = require('../getScene'); var pointerLocks = require('../pointLockers'); -var letsMove = require('../letsMove'); var controls = require('../controls'); var getRenderer = require('./getRenderer'); var getLight = require('./getLight'); @@ -102416,23 +102412,21 @@ var init = function init() { world.broadphase = new CANNON.NaiveBroadphase(); world.solver.iterations = 10; var shape = new CANNON.Box(new CANNON.Vec3(1, 1, 1)); - var mass = 1; var body = new CANNON.Body({ mass: 1 }); body.addShape(shape); - body.angularVelocity.set(0, 10, 0); + body.angularVelocity.set(0, 50, 0); body.angularDamping = 0.5; + body.position.set(0, 50, 0); world.addBody(body); - console.log('this is my world', world); - // const camera = new THREE.PerspectiveCamera(75, -50, 1, 1000); var camera = new THREE.PerspectiveCamera(75, window.innerWidth / window.innerHeight, 1, 1000); - //let's create the scene + // let's create the scene var scene = new THREE.Scene(); - //and our camera + // and our camera - //camera.position.set(0, 0, -5); + // camera.position.set(0, 0, -5); // camera.lookAt(0, 500, 0); // direction camera is looking getScene.init(scene); var pointerLockControls = new PointerLockControls(camera); @@ -102487,6 +102481,7 @@ var init = function init() { camera.updateProjectionMatrix(); renderer.setSize(window.innerWidth, window.innerHeight); } + console.log(scene.children[1]); return { camera: camera, scene: scene, @@ -102501,7 +102496,7 @@ var init = function init() { module.exports = init; -},{"../blocker":64,"../controls":65,"../cubes":66,"../getScene":68,"../letsMove":73,"../pointLockers":74,"./getFloor":69,"./getLight":70,"./getRenderer":71,"cannon":2,"three":62,"three-pointerlock":61}],73:[function(require,module,exports){ +},{"../blocker":64,"../controls":65,"../cubes":66,"../getScene":68,"../pointLockers":74,"./getFloor":69,"./getLight":70,"./getRenderer":71,"cannon":2,"three":62,"three-pointerlock":61}],73:[function(require,module,exports){ 'use strict'; var THREE = require('three'); @@ -102516,11 +102511,9 @@ var bullets = []; var velocity = new THREE.Vector3(); module.exports = function (camera, scene, objects, raycaster, prevTime, time, pointerLockControls, world, timeStep) { - console.log(objects); world.step(timeStep); - // objects.obj1.Mesh.position.copy(world.body.position); - // objects.obj1.Mesh.quaternion.copy(world.body.quaternion); - + scene.children[1].position.copy(world.bodies[0].position); + scene.children[1].quaternion.copy(world.bodies[0].quaternion); raycaster.ray.origin.copy(pointLockers().position); raycaster.ray.origin.y -= 10; @@ -102546,6 +102539,20 @@ module.exports = function (camera, scene, objects, raycaster, prevTime, time, po // shoot.bullet(scene); var bullet = new THREE.Mesh(new THREE.SphereGeometry(0.5, 8, 8), new THREE.MeshBasicMaterial()); + // const shape = new CANNON.Sphere(new CANNON.Vec3(0.5)); + // const body = new CANNON.Body({ + // mass: 1, + // }); + // body.addShape(shape); + // body.angularVelocity.set(0, 50, 0); + // body.angularDamping = 0.5; + // body.position.set( + // raycaster.ray.origin.x, + // raycaster.ray.origin.y, + // raycaster.ray.origin.z, + // ); + // world.addBody(body); + bullet.position.set(raycaster.ray.origin.x, raycaster.ray.origin.y, raycaster.ray.origin.z); bullet.velocity = new THREE.Vector3(-Math.sin(pointerLockControls.getObject().rotation._y), 0, -Math.cos(pointerLockControls.getObject().rotation._y)); diff --git a/src/init/init.js b/src/init/init.js index 637f9fe..62da172 100644 --- a/src/init/init.js +++ b/src/init/init.js @@ -49,10 +49,10 @@ const init = () => { mass: 1, }); body.addShape(shape); - body.angularVelocity.set(0, 10, 0); + body.angularVelocity.set(0, 50, 0); body.angularDamping = 0.5; + body.position.set(0, 50, 0); world.addBody(body); - // const camera = new THREE.PerspectiveCamera(75, -50, 1, 1000); const camera = new THREE.PerspectiveCamera(75, window.innerWidth / window.innerHeight, 1, 1000); // let's create the scene @@ -116,7 +116,7 @@ const init = () => { camera.updateProjectionMatrix(); renderer.setSize(window.innerWidth, window.innerHeight); } - console.log(objects); + console.log(scene.children[1]); return { camera, scene, diff --git a/src/letsMove.js b/src/letsMove.js index 010b55d..c2a6880 100644 --- a/src/letsMove.js +++ b/src/letsMove.js @@ -22,8 +22,8 @@ module.exports = function ( timeStep, ) { world.step(timeStep); - // objects.obj1.Mesh.position.copy(world.body.position); - // objects.obj1.Mesh.quaternion.copy(world.body.quaternion); + scene.children[1].position.copy(world.bodies[0].position); + scene.children[1].quaternion.copy(world.bodies[0].quaternion); raycaster.ray.origin.copy(pointLockers().position); @@ -53,6 +53,20 @@ module.exports = function ( new THREE.MeshBasicMaterial(), ); + // const shape = new CANNON.Sphere(new CANNON.Vec3(0.5)); + // const body = new CANNON.Body({ + // mass: 1, + // }); + // body.addShape(shape); + // body.angularVelocity.set(0, 50, 0); + // body.angularDamping = 0.5; + // body.position.set( + // raycaster.ray.origin.x, + // raycaster.ray.origin.y, + // raycaster.ray.origin.z, + // ); + // world.addBody(body); + bullet.position.set( raycaster.ray.origin.x, raycaster.ray.origin.y, From d643e24765a3b2b26f797473c4726e4a4e14c6a9 Mon Sep 17 00:00:00 2001 From: RogeredBacon Date: Thu, 7 Sep 2017 18:23:06 +0000 Subject: [PATCH 4/9] Further merge conflicts --- public/index.html | 65 +++++++++++++---------------------------------- 1 file changed, 17 insertions(+), 48 deletions(-) diff --git a/public/index.html b/public/index.html index 3ba62c6..8362274 100644 --- a/public/index.html +++ b/public/index.html @@ -1,26 +1,25 @@ -<<<<<<< HEAD + GD - - GD - - - - - + @@ -32,41 +31,11 @@ + + -======= - - - GD - - - - - - - - - -
- -
- Click to play -
- (W, A, S, D = Move, SPACE = Jump, MOUSE = Look around) -
- -
- - - - - - ->>>>>>> master From 838793f4002a2d2ac23ede8c2a67535568ffee48 Mon Sep 17 00:00:00 2001 From: Yahia Date: Fri, 8 Sep 2017 12:25:46 +0100 Subject: [PATCH 5/9] physics added to floor and to crate --- package-lock.json | 9267 +++++++++++++++++++++++++++++++++++++++++++++ src/init/init.js | 17 +- src/letsMove.js | 41 +- 3 files changed, 9303 insertions(+), 22 deletions(-) create mode 100644 package-lock.json diff --git a/package-lock.json b/package-lock.json new file mode 100644 index 0000000..33724c2 --- /dev/null +++ b/package-lock.json @@ -0,0 +1,9267 @@ +{ + "name": "facgame", + "version": "1.0.0", + "lockfileVersion": 1, + "requires": true, + "dependencies": { + "abbrev": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/abbrev/-/abbrev-1.1.0.tgz", + "integrity": "sha1-0FVMIlZjbi9W58LlrRg/hZQo2B8=", + "dev": true + }, + "accepts": { + "version": "1.3.4", + "resolved": "https://registry.npmjs.org/accepts/-/accepts-1.3.4.tgz", + "integrity": "sha1-hiRnWMfdbSGmR0/whKR0DsBesh8=", + "requires": { + "mime-types": "2.1.17", + "negotiator": "0.6.1" + } + }, + "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 + } + } + }, + "after": { + "version": "0.8.2", + "resolved": "https://registry.npmjs.org/after/-/after-0.8.2.tgz", + "integrity": "sha1-/ts5T58OAqqXaOcCvaI7UF+ufh8=" + }, + "ajv": { + "version": "5.2.2", + "resolved": "https://registry.npmjs.org/ajv/-/ajv-5.2.2.tgz", + "integrity": "sha1-R8aNaehvXZUxA7AHSpQw3GPaXjk=", + "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": "1.5.1", + "resolved": "https://registry.npmjs.org/ajv-keywords/-/ajv-keywords-1.5.1.tgz", + "integrity": "sha1-MU3QpLM2j609/NxU7eYXG4htrzw=", + "dev": true + }, + "ansi-escapes": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/ansi-escapes/-/ansi-escapes-2.0.0.tgz", + "integrity": "sha1-W65SvkJIeN2Xg+iRDj/Cki6DyBs=", + "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 + }, + "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" + } + }, + "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-flatten": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/array-flatten/-/array-flatten-1.1.1.tgz", + "integrity": "sha1-ml9pkFGx5wczKPKgCJaLZOopVdI=" + }, + "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 + }, + "arraybuffer.slice": { + "version": "0.0.6", + "resolved": "https://registry.npmjs.org/arraybuffer.slice/-/arraybuffer.slice-0.0.6.tgz", + "integrity": "sha1-8zshWfBTKj8xB6JywMz70a0peco=" + }, + "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": { + "version": "1.5.2", + "resolved": "https://registry.npmjs.org/async/-/async-1.5.2.tgz", + "integrity": "sha1-7GphrlZIDAw8skHJVhjiCJL5Zyo=" + }, + "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" + } + }, + "babel-core": { + "version": "6.26.0", + "resolved": "https://registry.npmjs.org/babel-core/-/babel-core-6.26.0.tgz", + "integrity": "sha1-rzL3izGm/O8RnIew/Y2XU/A6C7g=", + "dev": true, + "requires": { + "babel-code-frame": "6.26.0", + "babel-generator": "6.26.0", + "babel-helpers": "6.24.1", + "babel-messages": "6.23.0", + "babel-register": "6.26.0", + "babel-runtime": "6.26.0", + "babel-template": "6.26.0", + "babel-traverse": "6.26.0", + "babel-types": "6.26.0", + "babylon": "6.18.0", + "convert-source-map": "1.5.0", + "debug": "2.6.8", + "json5": "0.5.1", + "lodash": "4.17.4", + "minimatch": "3.0.4", + "path-is-absolute": "1.0.1", + "private": "0.1.7", + "slash": "1.0.0", + "source-map": "0.5.7" + } + }, + "babel-generator": { + "version": "6.26.0", + "resolved": "https://registry.npmjs.org/babel-generator/-/babel-generator-6.26.0.tgz", + "integrity": "sha1-rBriAHC3n248odMmlhMFN3TyDcU=", + "dev": true, + "requires": { + "babel-messages": "6.23.0", + "babel-runtime": "6.26.0", + "babel-types": "6.26.0", + "detect-indent": "4.0.0", + "jsesc": "1.3.0", + "lodash": "4.17.4", + "source-map": "0.5.7", + "trim-right": "1.0.1" + }, + "dependencies": { + "jsesc": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/jsesc/-/jsesc-1.3.0.tgz", + "integrity": "sha1-RsP+yMGJKxKwgz25vHYiF226s0s=", + "dev": true + } + } + }, + "babel-helper-call-delegate": { + "version": "6.24.1", + "resolved": "https://registry.npmjs.org/babel-helper-call-delegate/-/babel-helper-call-delegate-6.24.1.tgz", + "integrity": "sha1-7Oaqzdx25Bw0YfiL/Fdb0Nqi340=", + "dev": true, + "requires": { + "babel-helper-hoist-variables": "6.24.1", + "babel-runtime": "6.26.0", + "babel-traverse": "6.26.0", + "babel-types": "6.26.0" + } + }, + "babel-helper-define-map": { + "version": "6.26.0", + "resolved": "https://registry.npmjs.org/babel-helper-define-map/-/babel-helper-define-map-6.26.0.tgz", + "integrity": "sha1-pfVtq0GiX5fstJjH66ypgZ+Vvl8=", + "dev": true, + "requires": { + "babel-helper-function-name": "6.24.1", + "babel-runtime": "6.26.0", + "babel-types": "6.26.0", + "lodash": "4.17.4" + } + }, + "babel-helper-function-name": { + "version": "6.24.1", + "resolved": "https://registry.npmjs.org/babel-helper-function-name/-/babel-helper-function-name-6.24.1.tgz", + "integrity": "sha1-00dbjAPtmCQqJbSDUasYOZ01gKk=", + "dev": true, + "requires": { + "babel-helper-get-function-arity": "6.24.1", + "babel-runtime": "6.26.0", + "babel-template": "6.26.0", + "babel-traverse": "6.26.0", + "babel-types": "6.26.0" + } + }, + "babel-helper-get-function-arity": { + "version": "6.24.1", + "resolved": "https://registry.npmjs.org/babel-helper-get-function-arity/-/babel-helper-get-function-arity-6.24.1.tgz", + "integrity": "sha1-j3eCqpNAfEHTqlCQj4mwMbG2hT0=", + "dev": true, + "requires": { + "babel-runtime": "6.26.0", + "babel-types": "6.26.0" + } + }, + "babel-helper-hoist-variables": { + "version": "6.24.1", + "resolved": "https://registry.npmjs.org/babel-helper-hoist-variables/-/babel-helper-hoist-variables-6.24.1.tgz", + "integrity": "sha1-HssnaJydJVE+rbyZFKc/VAi+enY=", + "dev": true, + "requires": { + "babel-runtime": "6.26.0", + "babel-types": "6.26.0" + } + }, + "babel-helper-optimise-call-expression": { + "version": "6.24.1", + "resolved": "https://registry.npmjs.org/babel-helper-optimise-call-expression/-/babel-helper-optimise-call-expression-6.24.1.tgz", + "integrity": "sha1-96E0J7qfc/j0+pk8VKl4gtEkQlc=", + "dev": true, + "requires": { + "babel-runtime": "6.26.0", + "babel-types": "6.26.0" + } + }, + "babel-helper-regex": { + "version": "6.26.0", + "resolved": "https://registry.npmjs.org/babel-helper-regex/-/babel-helper-regex-6.26.0.tgz", + "integrity": "sha1-MlxZ+QL4LyS3T6zu0DY5VPZJXnI=", + "dev": true, + "requires": { + "babel-runtime": "6.26.0", + "babel-types": "6.26.0", + "lodash": "4.17.4" + } + }, + "babel-helper-replace-supers": { + "version": "6.24.1", + "resolved": "https://registry.npmjs.org/babel-helper-replace-supers/-/babel-helper-replace-supers-6.24.1.tgz", + "integrity": "sha1-v22/5Dk40XNpohPKiov3S2qQqxo=", + "dev": true, + "requires": { + "babel-helper-optimise-call-expression": "6.24.1", + "babel-messages": "6.23.0", + "babel-runtime": "6.26.0", + "babel-template": "6.26.0", + "babel-traverse": "6.26.0", + "babel-types": "6.26.0" + } + }, + "babel-helpers": { + "version": "6.24.1", + "resolved": "https://registry.npmjs.org/babel-helpers/-/babel-helpers-6.24.1.tgz", + "integrity": "sha1-NHHenK7DiOXIUOWX5Yom3fN2ArI=", + "dev": true, + "requires": { + "babel-runtime": "6.26.0", + "babel-template": "6.26.0" + } + }, + "babel-messages": { + "version": "6.23.0", + "resolved": "https://registry.npmjs.org/babel-messages/-/babel-messages-6.23.0.tgz", + "integrity": "sha1-8830cDhYA1sqKVHG7F7fbGLyYw4=", + "dev": true, + "requires": { + "babel-runtime": "6.26.0" + } + }, + "babel-plugin-check-es2015-constants": { + "version": "6.22.0", + "resolved": "https://registry.npmjs.org/babel-plugin-check-es2015-constants/-/babel-plugin-check-es2015-constants-6.22.0.tgz", + "integrity": "sha1-NRV7EBQm/S/9PaP3XH0ekYNbv4o=", + "dev": true, + "requires": { + "babel-runtime": "6.26.0" + } + }, + "babel-plugin-transform-es2015-arrow-functions": { + "version": "6.22.0", + "resolved": "https://registry.npmjs.org/babel-plugin-transform-es2015-arrow-functions/-/babel-plugin-transform-es2015-arrow-functions-6.22.0.tgz", + "integrity": "sha1-RSaSy3EdX3ncf4XkQM5BufJE0iE=", + "dev": true, + "requires": { + "babel-runtime": "6.26.0" + } + }, + "babel-plugin-transform-es2015-block-scoped-functions": { + "version": "6.22.0", + "resolved": "https://registry.npmjs.org/babel-plugin-transform-es2015-block-scoped-functions/-/babel-plugin-transform-es2015-block-scoped-functions-6.22.0.tgz", + "integrity": "sha1-u8UbSflk1wy42OC5ToICRs46YUE=", + "dev": true, + "requires": { + "babel-runtime": "6.26.0" + } + }, + "babel-plugin-transform-es2015-block-scoping": { + "version": "6.26.0", + "resolved": "https://registry.npmjs.org/babel-plugin-transform-es2015-block-scoping/-/babel-plugin-transform-es2015-block-scoping-6.26.0.tgz", + "integrity": "sha1-1w9SmcEwjQXBL0Y4E7CgnnOxiV8=", + "dev": true, + "requires": { + "babel-runtime": "6.26.0", + "babel-template": "6.26.0", + "babel-traverse": "6.26.0", + "babel-types": "6.26.0", + "lodash": "4.17.4" + } + }, + "babel-plugin-transform-es2015-classes": { + "version": "6.24.1", + "resolved": "https://registry.npmjs.org/babel-plugin-transform-es2015-classes/-/babel-plugin-transform-es2015-classes-6.24.1.tgz", + "integrity": "sha1-WkxYpQyclGHlZLSyo7+ryXolhNs=", + "dev": true, + "requires": { + "babel-helper-define-map": "6.26.0", + "babel-helper-function-name": "6.24.1", + "babel-helper-optimise-call-expression": "6.24.1", + "babel-helper-replace-supers": "6.24.1", + "babel-messages": "6.23.0", + "babel-runtime": "6.26.0", + "babel-template": "6.26.0", + "babel-traverse": "6.26.0", + "babel-types": "6.26.0" + } + }, + "babel-plugin-transform-es2015-computed-properties": { + "version": "6.24.1", + "resolved": "https://registry.npmjs.org/babel-plugin-transform-es2015-computed-properties/-/babel-plugin-transform-es2015-computed-properties-6.24.1.tgz", + "integrity": "sha1-b+Ko0WiV1WNPTNmZttNICjCBWbM=", + "dev": true, + "requires": { + "babel-runtime": "6.26.0", + "babel-template": "6.26.0" + } + }, + "babel-plugin-transform-es2015-destructuring": { + "version": "6.23.0", + "resolved": "https://registry.npmjs.org/babel-plugin-transform-es2015-destructuring/-/babel-plugin-transform-es2015-destructuring-6.23.0.tgz", + "integrity": "sha1-mXux8auWf2gtKwh2/jWNYOdlxW0=", + "dev": true, + "requires": { + "babel-runtime": "6.26.0" + } + }, + "babel-plugin-transform-es2015-duplicate-keys": { + "version": "6.24.1", + "resolved": "https://registry.npmjs.org/babel-plugin-transform-es2015-duplicate-keys/-/babel-plugin-transform-es2015-duplicate-keys-6.24.1.tgz", + "integrity": "sha1-c+s9MQypaePvnskcU3QabxV2Qj4=", + "dev": true, + "requires": { + "babel-runtime": "6.26.0", + "babel-types": "6.26.0" + } + }, + "babel-plugin-transform-es2015-for-of": { + "version": "6.23.0", + "resolved": "https://registry.npmjs.org/babel-plugin-transform-es2015-for-of/-/babel-plugin-transform-es2015-for-of-6.23.0.tgz", + "integrity": "sha1-9HyVsrYT3x0+zC/bdXNiPHUkhpE=", + "dev": true, + "requires": { + "babel-runtime": "6.26.0" + } + }, + "babel-plugin-transform-es2015-function-name": { + "version": "6.24.1", + "resolved": "https://registry.npmjs.org/babel-plugin-transform-es2015-function-name/-/babel-plugin-transform-es2015-function-name-6.24.1.tgz", + "integrity": "sha1-g0yJhTvDaxrw86TF26qU/Y6sqos=", + "dev": true, + "requires": { + "babel-helper-function-name": "6.24.1", + "babel-runtime": "6.26.0", + "babel-types": "6.26.0" + } + }, + "babel-plugin-transform-es2015-literals": { + "version": "6.22.0", + "resolved": "https://registry.npmjs.org/babel-plugin-transform-es2015-literals/-/babel-plugin-transform-es2015-literals-6.22.0.tgz", + "integrity": "sha1-T1SgLWzWbPkVKAAZox0xklN3yi4=", + "dev": true, + "requires": { + "babel-runtime": "6.26.0" + } + }, + "babel-plugin-transform-es2015-modules-amd": { + "version": "6.24.1", + "resolved": "https://registry.npmjs.org/babel-plugin-transform-es2015-modules-amd/-/babel-plugin-transform-es2015-modules-amd-6.24.1.tgz", + "integrity": "sha1-Oz5UAXI5hC1tGcMBHEvS8AoA0VQ=", + "dev": true, + "requires": { + "babel-plugin-transform-es2015-modules-commonjs": "6.26.0", + "babel-runtime": "6.26.0", + "babel-template": "6.26.0" + } + }, + "babel-plugin-transform-es2015-modules-commonjs": { + "version": "6.26.0", + "resolved": "https://registry.npmjs.org/babel-plugin-transform-es2015-modules-commonjs/-/babel-plugin-transform-es2015-modules-commonjs-6.26.0.tgz", + "integrity": "sha1-DYOUApt9xqvhqX7xgeAHWN0uXYo=", + "dev": true, + "requires": { + "babel-plugin-transform-strict-mode": "6.24.1", + "babel-runtime": "6.26.0", + "babel-template": "6.26.0", + "babel-types": "6.26.0" + } + }, + "babel-plugin-transform-es2015-modules-systemjs": { + "version": "6.24.1", + "resolved": "https://registry.npmjs.org/babel-plugin-transform-es2015-modules-systemjs/-/babel-plugin-transform-es2015-modules-systemjs-6.24.1.tgz", + "integrity": "sha1-/4mhQrkRmpBhlfXxBuzzBdlAfSM=", + "dev": true, + "requires": { + "babel-helper-hoist-variables": "6.24.1", + "babel-runtime": "6.26.0", + "babel-template": "6.26.0" + } + }, + "babel-plugin-transform-es2015-modules-umd": { + "version": "6.24.1", + "resolved": "https://registry.npmjs.org/babel-plugin-transform-es2015-modules-umd/-/babel-plugin-transform-es2015-modules-umd-6.24.1.tgz", + "integrity": "sha1-rJl+YoXNGO1hdq22B9YCNErThGg=", + "dev": true, + "requires": { + "babel-plugin-transform-es2015-modules-amd": "6.24.1", + "babel-runtime": "6.26.0", + "babel-template": "6.26.0" + } + }, + "babel-plugin-transform-es2015-object-super": { + "version": "6.24.1", + "resolved": "https://registry.npmjs.org/babel-plugin-transform-es2015-object-super/-/babel-plugin-transform-es2015-object-super-6.24.1.tgz", + "integrity": "sha1-JM72muIcuDp/hgPa0CH1cusnj40=", + "dev": true, + "requires": { + "babel-helper-replace-supers": "6.24.1", + "babel-runtime": "6.26.0" + } + }, + "babel-plugin-transform-es2015-parameters": { + "version": "6.24.1", + "resolved": "https://registry.npmjs.org/babel-plugin-transform-es2015-parameters/-/babel-plugin-transform-es2015-parameters-6.24.1.tgz", + "integrity": "sha1-V6w1GrScrxSpfNE7CfZv3wpiXys=", + "dev": true, + "requires": { + "babel-helper-call-delegate": "6.24.1", + "babel-helper-get-function-arity": "6.24.1", + "babel-runtime": "6.26.0", + "babel-template": "6.26.0", + "babel-traverse": "6.26.0", + "babel-types": "6.26.0" + } + }, + "babel-plugin-transform-es2015-shorthand-properties": { + "version": "6.24.1", + "resolved": "https://registry.npmjs.org/babel-plugin-transform-es2015-shorthand-properties/-/babel-plugin-transform-es2015-shorthand-properties-6.24.1.tgz", + "integrity": "sha1-JPh11nIch2YbvZmkYi5R8U3jiqA=", + "dev": true, + "requires": { + "babel-runtime": "6.26.0", + "babel-types": "6.26.0" + } + }, + "babel-plugin-transform-es2015-spread": { + "version": "6.22.0", + "resolved": "https://registry.npmjs.org/babel-plugin-transform-es2015-spread/-/babel-plugin-transform-es2015-spread-6.22.0.tgz", + "integrity": "sha1-1taKmfia7cRTbIGlQujdnxdG+NE=", + "dev": true, + "requires": { + "babel-runtime": "6.26.0" + } + }, + "babel-plugin-transform-es2015-sticky-regex": { + "version": "6.24.1", + "resolved": "https://registry.npmjs.org/babel-plugin-transform-es2015-sticky-regex/-/babel-plugin-transform-es2015-sticky-regex-6.24.1.tgz", + "integrity": "sha1-AMHNsaynERLN8M9hJsLta0V8zbw=", + "dev": true, + "requires": { + "babel-helper-regex": "6.26.0", + "babel-runtime": "6.26.0", + "babel-types": "6.26.0" + } + }, + "babel-plugin-transform-es2015-template-literals": { + "version": "6.22.0", + "resolved": "https://registry.npmjs.org/babel-plugin-transform-es2015-template-literals/-/babel-plugin-transform-es2015-template-literals-6.22.0.tgz", + "integrity": "sha1-qEs0UPfp+PH2g51taH2oS7EjbY0=", + "dev": true, + "requires": { + "babel-runtime": "6.26.0" + } + }, + "babel-plugin-transform-es2015-typeof-symbol": { + "version": "6.23.0", + "resolved": "https://registry.npmjs.org/babel-plugin-transform-es2015-typeof-symbol/-/babel-plugin-transform-es2015-typeof-symbol-6.23.0.tgz", + "integrity": "sha1-3sCfHN3/lLUqxz1QXITfWdzOs3I=", + "dev": true, + "requires": { + "babel-runtime": "6.26.0" + } + }, + "babel-plugin-transform-es2015-unicode-regex": { + "version": "6.24.1", + "resolved": "https://registry.npmjs.org/babel-plugin-transform-es2015-unicode-regex/-/babel-plugin-transform-es2015-unicode-regex-6.24.1.tgz", + "integrity": "sha1-04sS9C6nMj9yk4fxinxa4frrNek=", + "dev": true, + "requires": { + "babel-helper-regex": "6.26.0", + "babel-runtime": "6.26.0", + "regexpu-core": "2.0.0" + } + }, + "babel-plugin-transform-regenerator": { + "version": "6.26.0", + "resolved": "https://registry.npmjs.org/babel-plugin-transform-regenerator/-/babel-plugin-transform-regenerator-6.26.0.tgz", + "integrity": "sha1-4HA2lvveJ/Cj78rPi03KL3s6jy8=", + "dev": true, + "requires": { + "regenerator-transform": "0.10.1" + } + }, + "babel-plugin-transform-strict-mode": { + "version": "6.24.1", + "resolved": "https://registry.npmjs.org/babel-plugin-transform-strict-mode/-/babel-plugin-transform-strict-mode-6.24.1.tgz", + "integrity": "sha1-1fr3qleKZbvlkc9e2uBKDGcCB1g=", + "dev": true, + "requires": { + "babel-runtime": "6.26.0", + "babel-types": "6.26.0" + } + }, + "babel-preset-es2015": { + "version": "6.24.1", + "resolved": "https://registry.npmjs.org/babel-preset-es2015/-/babel-preset-es2015-6.24.1.tgz", + "integrity": "sha1-1EBQ1rwsn+6nAqrzjXJ6AhBTiTk=", + "dev": true, + "requires": { + "babel-plugin-check-es2015-constants": "6.22.0", + "babel-plugin-transform-es2015-arrow-functions": "6.22.0", + "babel-plugin-transform-es2015-block-scoped-functions": "6.22.0", + "babel-plugin-transform-es2015-block-scoping": "6.26.0", + "babel-plugin-transform-es2015-classes": "6.24.1", + "babel-plugin-transform-es2015-computed-properties": "6.24.1", + "babel-plugin-transform-es2015-destructuring": "6.23.0", + "babel-plugin-transform-es2015-duplicate-keys": "6.24.1", + "babel-plugin-transform-es2015-for-of": "6.23.0", + "babel-plugin-transform-es2015-function-name": "6.24.1", + "babel-plugin-transform-es2015-literals": "6.22.0", + "babel-plugin-transform-es2015-modules-amd": "6.24.1", + "babel-plugin-transform-es2015-modules-commonjs": "6.26.0", + "babel-plugin-transform-es2015-modules-systemjs": "6.24.1", + "babel-plugin-transform-es2015-modules-umd": "6.24.1", + "babel-plugin-transform-es2015-object-super": "6.24.1", + "babel-plugin-transform-es2015-parameters": "6.24.1", + "babel-plugin-transform-es2015-shorthand-properties": "6.24.1", + "babel-plugin-transform-es2015-spread": "6.22.0", + "babel-plugin-transform-es2015-sticky-regex": "6.24.1", + "babel-plugin-transform-es2015-template-literals": "6.22.0", + "babel-plugin-transform-es2015-typeof-symbol": "6.23.0", + "babel-plugin-transform-es2015-unicode-regex": "6.24.1", + "babel-plugin-transform-regenerator": "6.26.0" + } + }, + "babel-register": { + "version": "6.26.0", + "resolved": "https://registry.npmjs.org/babel-register/-/babel-register-6.26.0.tgz", + "integrity": "sha1-btAhFz4vy0htestFxgCahW9kcHE=", + "dev": true, + "requires": { + "babel-core": "6.26.0", + "babel-runtime": "6.26.0", + "core-js": "2.5.1", + "home-or-tmp": "2.0.0", + "lodash": "4.17.4", + "mkdirp": "0.5.1", + "source-map-support": "0.4.17" + } + }, + "babel-runtime": { + "version": "6.26.0", + "resolved": "https://registry.npmjs.org/babel-runtime/-/babel-runtime-6.26.0.tgz", + "integrity": "sha1-llxwWGaOgrVde/4E/yM3vItWR/4=", + "dev": true, + "requires": { + "core-js": "2.5.1", + "regenerator-runtime": "0.11.0" + } + }, + "babel-template": { + "version": "6.26.0", + "resolved": "https://registry.npmjs.org/babel-template/-/babel-template-6.26.0.tgz", + "integrity": "sha1-3gPi0WOWsGn0bdn/+FIfsaDjXgI=", + "dev": true, + "requires": { + "babel-runtime": "6.26.0", + "babel-traverse": "6.26.0", + "babel-types": "6.26.0", + "babylon": "6.18.0", + "lodash": "4.17.4" + } + }, + "babel-traverse": { + "version": "6.26.0", + "resolved": "https://registry.npmjs.org/babel-traverse/-/babel-traverse-6.26.0.tgz", + "integrity": "sha1-RqnL1+3MYsjlwGTi0tjQ9ANXZu4=", + "dev": true, + "requires": { + "babel-code-frame": "6.26.0", + "babel-messages": "6.23.0", + "babel-runtime": "6.26.0", + "babel-types": "6.26.0", + "babylon": "6.18.0", + "debug": "2.6.8", + "globals": "9.18.0", + "invariant": "2.2.2", + "lodash": "4.17.4" + } + }, + "babel-types": { + "version": "6.26.0", + "resolved": "https://registry.npmjs.org/babel-types/-/babel-types-6.26.0.tgz", + "integrity": "sha1-o7Bz+Uq0nrb6Vc1lInozQ4BjJJc=", + "dev": true, + "requires": { + "babel-runtime": "6.26.0", + "esutils": "2.0.2", + "lodash": "4.17.4", + "to-fast-properties": "1.0.3" + } + }, + "babelify": { + "version": "7.3.0", + "resolved": "https://registry.npmjs.org/babelify/-/babelify-7.3.0.tgz", + "integrity": "sha1-qlau3nBn/XvVSWZu4W3ChQh+iOU=", + "dev": true, + "requires": { + "babel-core": "6.26.0", + "object-assign": "4.1.1" + } + }, + "babylon": { + "version": "6.18.0", + "resolved": "https://registry.npmjs.org/babylon/-/babylon-6.18.0.tgz", + "integrity": "sha512-q/UEjfGJ2Cm3oKV71DJz9d25TPnq5rhBVL2Q4fA5wcC3jcrdn7+SssEybFIxwAvvP+YCsCYNKughoF33GxgycQ==", + "dev": true + }, + "backo2": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/backo2/-/backo2-1.0.2.tgz", + "integrity": "sha1-MasayLEpNjRj41s+u2n038+6eUc=" + }, + "balanced-match": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.0.tgz", + "integrity": "sha1-ibTRmasr7kneFk6gK4nORi1xt2c=", + "dev": true + }, + "base64-arraybuffer": { + "version": "0.1.5", + "resolved": "https://registry.npmjs.org/base64-arraybuffer/-/base64-arraybuffer-0.1.5.tgz", + "integrity": "sha1-c5JncZI7Whl0etZmqlzUv5xunOg=" + }, + "base64-js": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/base64-js/-/base64-js-1.2.1.tgz", + "integrity": "sha512-dwVUVIXsBZXwTuwnXI9RK8sBmgq09NDHzyR9SAph9eqk76gKK2JSQmZARC2zRC81JC2QTtxD0ARU5qTS25gIGw==", + "dev": true + }, + "base64id": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/base64id/-/base64id-1.0.0.tgz", + "integrity": "sha1-R2iMuZu2gE8OBtPnY7HDLlfY5rY=" + }, + "better-assert": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/better-assert/-/better-assert-1.0.2.tgz", + "integrity": "sha1-QIZrnhueC1W0gYlDEeaPr/rrxSI=", + "requires": { + "callsite": "1.0.0" + } + }, + "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 + }, + "blob": { + "version": "0.0.4", + "resolved": "https://registry.npmjs.org/blob/-/blob-0.0.4.tgz", + "integrity": "sha1-vPEwUspURj8w+fx+lbmkdjCpSSE=" + }, + "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 + }, + "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": { + "combine-source-map": "0.7.2", + "defined": "1.0.0", + "JSONStream": "1.3.1", + "through2": "2.0.3", + "umd": "3.0.1" + } + }, + "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 + } + } + }, + "browserify": { + "version": "14.4.0", + "resolved": "https://registry.npmjs.org/browserify/-/browserify-14.4.0.tgz", + "integrity": "sha1-CJo0Y69Y0OSNjNQHCz90ZU1avKk=", + "dev": true, + "requires": { + "assert": "1.4.1", + "browser-pack": "6.0.2", + "browser-resolve": "1.11.2", + "browserify-zlib": "0.1.4", + "buffer": "5.0.7", + "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", + "JSONStream": "1.3.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.6", + "resolved": "https://registry.npmjs.org/browserify-aes/-/browserify-aes-1.0.6.tgz", + "integrity": "sha1-Xncl297x/Vkw1OurSFZ85FHEigo=", + "dev": true, + "requires": { + "buffer-xor": "1.0.3", + "cipher-base": "1.0.4", + "create-hash": "1.1.3", + "evp_bytestokey": "1.0.2", + "inherits": "2.0.3" + } + }, + "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.6", + "browserify-des": "1.0.0", + "evp_bytestokey": "1.0.2" + } + }, + "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.7", + "resolved": "https://registry.npmjs.org/buffer/-/buffer-5.0.7.tgz", + "integrity": "sha512-NeeHXWh5pCbPQCt2/6rLvXqapZfVsqw/YgRgaHpT3H9Uzgs+S0lSg5SQzouIuDvcmlQRqBe8hOO2scKCu3cxrg==", + "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" + } + }, + "callsite": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/callsite/-/callsite-1.0.0.tgz", + "integrity": "sha1-KAOY5dZkvXQDi28JBRU+borxvCA=" + }, + "callsites": { + "version": "0.2.0", + "resolved": "https://registry.npmjs.org/callsites/-/callsites-0.2.0.tgz", + "integrity": "sha1-r6uWJikQp/M8GaV3WCXGnzTjUMo=", + "dev": true + }, + "cannon": { + "version": "github:schteppe/cannon.js#569730f94a1d9da47967a24fad0323ef7d5b4119" + }, + "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" + } + }, + "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", + "fsevents": "1.1.2", + "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" + } + }, + "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-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 + }, + "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 + }, + "colors": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/colors/-/colors-1.0.3.tgz", + "integrity": "sha1-BDP0TYCWgP3rYO0mDxsMJi6CpAs=" + }, + "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" + }, + "dependencies": { + "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 + } + } + }, + "component-bind": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/component-bind/-/component-bind-1.0.0.tgz", + "integrity": "sha1-AMYIq33Nk4l8AAllGx06jh5zu9E=" + }, + "component-emitter": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/component-emitter/-/component-emitter-1.2.1.tgz", + "integrity": "sha1-E3kY1teCg/ffemt8WmPhQOaUJeY=" + }, + "component-inherit": { + "version": "0.0.3", + "resolved": "https://registry.npmjs.org/component-inherit/-/component-inherit-0.0.3.tgz", + "integrity": "sha1-ZF/ErfWLcrZJ1crmUTVhnbJv8UM=" + }, + "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 + } + } + }, + "configstore": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/configstore/-/configstore-1.4.0.tgz", + "integrity": "sha1-w1eB0FAdJowlxUuLF/YkDopPsCE=", + "dev": true, + "requires": { + "graceful-fs": "4.1.11", + "mkdirp": "0.5.1", + "object-assign": "4.1.1", + "os-tmpdir": "1.0.2", + "osenv": "0.1.4", + "uuid": "2.0.3", + "write-file-atomic": "1.3.4", + "xdg-basedir": "2.0.0" + } + }, + "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" + } + }, + "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 + }, + "contains-path": { + "version": "0.1.0", + "resolved": "https://registry.npmjs.org/contains-path/-/contains-path-0.1.0.tgz", + "integrity": "sha1-/ozxhP9mcLa67wGp1IYaXL7EEgo=", + "dev": true + }, + "content-disposition": { + "version": "0.5.2", + "resolved": "https://registry.npmjs.org/content-disposition/-/content-disposition-0.5.2.tgz", + "integrity": "sha1-DPaLud318r55YcOoUXjLhdunjLQ=" + }, + "content-type": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/content-type/-/content-type-1.0.2.tgz", + "integrity": "sha1-t9ETrueo3Se9IRM8TcJSnfFyHu0=" + }, + "convert-source-map": { + "version": "1.5.0", + "resolved": "https://registry.npmjs.org/convert-source-map/-/convert-source-map-1.5.0.tgz", + "integrity": "sha1-ms1whRxtXf3ZPZKC5e35SgP/RrU=", + "dev": true + }, + "cookie": { + "version": "0.3.1", + "resolved": "https://registry.npmjs.org/cookie/-/cookie-0.3.1.tgz", + "integrity": "sha1-5+Ch+e9DtMi6klxcWpboBtFoc7s=" + }, + "cookie-signature": { + "version": "1.0.6", + "resolved": "https://registry.npmjs.org/cookie-signature/-/cookie-signature-1.0.6.tgz", + "integrity": "sha1-4wOogrNCzD7oylE6eZmXNNqzriw=" + }, + "core-js": { + "version": "2.5.1", + "resolved": "https://registry.npmjs.org/core-js/-/core-js-2.5.1.tgz", + "integrity": "sha1-rmh03GaTd4m4B1T/VCjfZoGcpQs=", + "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 + }, + "corser": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/corser/-/corser-2.0.1.tgz", + "integrity": "sha1-jtolLsqrWEDc2XXOuQ2TcMgZ/4c=" + }, + "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.8" + } + }, + "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.8" + } + }, + "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" + } + }, + "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.13", + "public-encrypt": "4.0.0", + "randombytes": "2.0.5" + } + }, + "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": "2.6.8", + "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.8.tgz", + "integrity": "sha1-5zFTHKLt4n0YgiJCfaF4IdaP9Pw=", + "requires": { + "ms": "2.0.0" + } + }, + "deep-extend": { + "version": "0.4.2", + "resolved": "https://registry.npmjs.org/deep-extend/-/deep-extend-0.4.2.tgz", + "integrity": "sha1-SLaZwn4zS/ifEIkr5DL25MfTSn8=", + "dev": true + }, + "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 + }, + "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.1" + } + }, + "depd": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/depd/-/depd-1.1.1.tgz", + "integrity": "sha1-V4O04cRZ8G+lyif5kfPQbnoxA1k=" + }, + "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" + } + }, + "destroy": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/destroy/-/destroy-1.0.4.tgz", + "integrity": "sha1-l4hXRCxEdJ5CBmE+N5RiBYJqvYA=" + }, + "detect-indent": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/detect-indent/-/detect-indent-4.0.0.tgz", + "integrity": "sha1-920GQ1LN9Docts5hnE7jqUdd4gg=", + "dev": true, + "requires": { + "repeating": "2.0.1" + } + }, + "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" + } + }, + "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.0", + "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" + } + }, + "duplexify": { + "version": "3.5.1", + "resolved": "https://registry.npmjs.org/duplexify/-/duplexify-3.5.1.tgz", + "integrity": "sha512-j5goxHTwVED1Fpe5hh3q9R93Kip0Bg2KVAt4f8CEYM3UEwYcPSvWbXaUQOzdX/HtiNomipv+gU7ASQPDbV7pGQ==", + "dev": true, + "requires": { + "end-of-stream": "1.4.0", + "inherits": "2.0.3", + "readable-stream": "2.3.3", + "stream-shift": "1.0.0" + } + }, + "ecstatic": { + "version": "2.2.1", + "resolved": "https://registry.npmjs.org/ecstatic/-/ecstatic-2.2.1.tgz", + "integrity": "sha512-ztE4WqheoWLh3wv+HQwy7dACnvNY620coWpa+XqY6R2cVWgaAT2lUISU1Uf7JpdLLJCURktJOaA9av2AOzsyYQ==", + "requires": { + "he": "1.1.1", + "mime": "1.4.0", + "minimist": "1.2.0", + "url-join": "2.0.2" + } + }, + "ee-first": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/ee-first/-/ee-first-1.1.1.tgz", + "integrity": "sha1-WQxhFWsK4vTwJVcyoViyZrxWsh0=" + }, + "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" + } + }, + "encodeurl": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/encodeurl/-/encodeurl-1.0.1.tgz", + "integrity": "sha1-eePVhlU0aQn+bw9Fpd5oEDspTSA=" + }, + "end-of-stream": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/end-of-stream/-/end-of-stream-1.4.0.tgz", + "integrity": "sha1-epDYM+/abPpurA9JSduw+tOmMgY=", + "dev": true, + "requires": { + "once": "1.4.0" + } + }, + "engine.io": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/engine.io/-/engine.io-3.1.1.tgz", + "integrity": "sha1-CAUf+5UZB6MmfnLgvLPQ83fkZgs=", + "requires": { + "accepts": "1.3.3", + "base64id": "1.0.0", + "cookie": "0.3.1", + "debug": "2.6.8", + "engine.io-parser": "2.1.1", + "uws": "0.14.5", + "ws": "2.3.1" + }, + "dependencies": { + "accepts": { + "version": "1.3.3", + "resolved": "https://registry.npmjs.org/accepts/-/accepts-1.3.3.tgz", + "integrity": "sha1-w8p0NJOGSMPg2cHjKN1otiLChMo=", + "requires": { + "mime-types": "2.1.17", + "negotiator": "0.6.1" + } + } + } + }, + "engine.io-client": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/engine.io-client/-/engine.io-client-3.1.1.tgz", + "integrity": "sha1-QVqYUrrbFPoAj6PvHjFgjbZ2EyU=", + "requires": { + "component-emitter": "1.2.1", + "component-inherit": "0.0.3", + "debug": "2.6.8", + "engine.io-parser": "2.1.1", + "has-cors": "1.1.0", + "indexof": "0.0.1", + "parsejson": "0.0.3", + "parseqs": "0.0.5", + "parseuri": "0.0.5", + "ws": "2.3.1", + "xmlhttprequest-ssl": "1.5.3", + "yeast": "0.1.2" + } + }, + "engine.io-parser": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/engine.io-parser/-/engine.io-parser-2.1.1.tgz", + "integrity": "sha1-4Ps/DgRi9/WLt3waUun1p+JuRmg=", + "requires": { + "after": "0.8.2", + "arraybuffer.slice": "0.0.6", + "base64-arraybuffer": "0.1.5", + "blob": "0.0.4", + "has-binary2": "1.0.2" + } + }, + "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" + } + }, + "es6-promise": { + "version": "3.3.1", + "resolved": "https://registry.npmjs.org/es6-promise/-/es6-promise-3.3.1.tgz", + "integrity": "sha1-oIzd6EzNvzTQJ6FFG8kdS80ophM=", + "dev": true + }, + "escape-html": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/escape-html/-/escape-html-1.0.3.tgz", + "integrity": "sha1-Aljq5NPQwJdN4cFpGI7wBR0dGYg=" + }, + "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.6.1", + "resolved": "https://registry.npmjs.org/eslint/-/eslint-4.6.1.tgz", + "integrity": "sha1-3cf8f9cL+TIFsLNEm7FqHp59SVA=", + "dev": true, + "requires": { + "ajv": "5.2.2", + "babel-code-frame": "6.26.0", + "chalk": "2.1.0", + "concat-stream": "1.6.0", + "cross-spawn": "5.1.0", + "debug": "2.6.8", + "doctrine": "2.0.0", + "eslint-scope": "3.7.1", + "espree": "3.5.0", + "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.2.3", + "is-resolvable": "1.0.0", + "js-yaml": "3.9.1", + "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": "4.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.1", + "text-table": "0.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" + } + }, + "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" + } + }, + "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" + } + }, + "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" + } + }, + "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" + } + } + } + }, + "eslint-config-airbnb-base": { + "version": "12.0.0", + "resolved": "https://registry.npmjs.org/eslint-config-airbnb-base/-/eslint-config-airbnb-base-12.0.0.tgz", + "integrity": "sha512-/XlFQGn3Mkwm642/GYBtOH3pgFX4Z7saBsqqyp96v0bEUPq24nIrZ6N72qAoD0lR2wAne4EC4YsHYkbPfaRfiA==", + "dev": true, + "requires": { + "eslint-restricted-globals": "0.1.1" + } + }, + "eslint-import-resolver-node": { + "version": "0.3.1", + "resolved": "https://registry.npmjs.org/eslint-import-resolver-node/-/eslint-import-resolver-node-0.3.1.tgz", + "integrity": "sha512-yUtXS15gIcij68NmXmP9Ni77AQuCN0itXbCc/jWd8C6/yKZaSNXicpC8cgvjnxVdmfsosIXrjpzFq7GcDryb6A==", + "dev": true, + "requires": { + "debug": "2.6.8", + "resolve": "1.4.0" + } + }, + "eslint-module-utils": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/eslint-module-utils/-/eslint-module-utils-2.1.1.tgz", + "integrity": "sha512-jDI/X5l/6D1rRD/3T43q8Qgbls2nq5km5KSqiwlyUbGo5+04fXhMKdCPhjwbqAa6HXWaMxj8Q4hQDIh7IadJQw==", + "dev": true, + "requires": { + "debug": "2.6.8", + "pkg-dir": "1.0.0" + } + }, + "eslint-plugin-import": { + "version": "2.7.0", + "resolved": "https://registry.npmjs.org/eslint-plugin-import/-/eslint-plugin-import-2.7.0.tgz", + "integrity": "sha512-HGYmpU9f/zJaQiKNQOVfHUh2oLWW3STBrCgH0sHTX1xtsxYlH1zjLh8FlQGEIdZSdTbUMaV36WaZ6ImXkenGxQ==", + "dev": true, + "requires": { + "builtin-modules": "1.1.1", + "contains-path": "0.1.0", + "debug": "2.6.8", + "doctrine": "1.5.0", + "eslint-import-resolver-node": "0.3.1", + "eslint-module-utils": "2.1.1", + "has": "1.0.1", + "lodash.cond": "4.5.2", + "minimatch": "3.0.4", + "read-pkg-up": "2.0.0" + }, + "dependencies": { + "doctrine": { + "version": "1.5.0", + "resolved": "https://registry.npmjs.org/doctrine/-/doctrine-1.5.0.tgz", + "integrity": "sha1-N53Ocw9hZvds76TmcHoVmwLFpvo=", + "dev": true, + "requires": { + "esutils": "2.0.2", + "isarray": "1.0.0" + } + } + } + }, + "eslint-restricted-globals": { + "version": "0.1.1", + "resolved": "https://registry.npmjs.org/eslint-restricted-globals/-/eslint-restricted-globals-0.1.1.tgz", + "integrity": "sha1-NfDVy8ZMLj7WLpO0saevBbp+1Nc=", + "dev": true + }, + "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.0", + "resolved": "https://registry.npmjs.org/espree/-/espree-3.5.0.tgz", + "integrity": "sha1-mDWGJb3QVYYeon4oZ+pyn69GPY0=", + "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 + }, + "etag": { + "version": "1.8.0", + "resolved": "https://registry.npmjs.org/etag/-/etag-1.8.0.tgz", + "integrity": "sha1-b2Ma7zNtbEY2K1F2QETOIWvjwFE=" + }, + "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" + } + }, + "eventemitter3": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/eventemitter3/-/eventemitter3-1.2.0.tgz", + "integrity": "sha1-HIaZHYFq0eUEdQ5zh0Ik7PO+xQg=" + }, + "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.2", + "resolved": "https://registry.npmjs.org/evp_bytestokey/-/evp_bytestokey-1.0.2.tgz", + "integrity": "sha512-ni0r0lrm7AOzsh2qC5mi9sj8S0gmj5fLNjfFpxN05FB4tAVZEKotbkjOtLPqTCX/CXT7NsUr6juZb4IFJeNNdA==", + "dev": true, + "requires": { + "md5.js": "1.3.4", + "safe-buffer": "5.1.1" + } + }, + "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" + } + }, + "express": { + "version": "4.15.4", + "resolved": "https://registry.npmjs.org/express/-/express-4.15.4.tgz", + "integrity": "sha1-Ay4iU0ic+PzgJma+yj0R7XotrtE=", + "requires": { + "accepts": "1.3.4", + "array-flatten": "1.1.1", + "content-disposition": "0.5.2", + "content-type": "1.0.2", + "cookie": "0.3.1", + "cookie-signature": "1.0.6", + "debug": "2.6.8", + "depd": "1.1.1", + "encodeurl": "1.0.1", + "escape-html": "1.0.3", + "etag": "1.8.0", + "finalhandler": "1.0.4", + "fresh": "0.5.0", + "merge-descriptors": "1.0.1", + "methods": "1.1.2", + "on-finished": "2.3.0", + "parseurl": "1.3.1", + "path-to-regexp": "0.1.7", + "proxy-addr": "1.1.5", + "qs": "6.5.0", + "range-parser": "1.2.0", + "send": "0.15.4", + "serve-static": "1.12.4", + "setprototypeof": "1.0.3", + "statuses": "1.3.1", + "type-is": "1.6.15", + "utils-merge": "1.0.0", + "vary": "1.1.1" + }, + "dependencies": { + "qs": { + "version": "6.5.0", + "resolved": "https://registry.npmjs.org/qs/-/qs-6.5.0.tgz", + "integrity": "sha512-fjVFjW9yhqMhVGwRExCXLhJKrLlkYSaxNWdyc9rmHlrVZbk35YHH312dFd7191uQeXkI3mKLZTIbSvIeFwFemg==" + } + } + }, + "external-editor": { + "version": "2.0.4", + "resolved": "https://registry.npmjs.org/external-editor/-/external-editor-2.0.4.tgz", + "integrity": "sha1-HtkZnanL/i7y96MbL96LDRI2iXI=", + "dev": true, + "requires": { + "iconv-lite": "0.4.18", + "jschardet": "1.5.1", + "tmp": "0.0.31" + } + }, + "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" + } + }, + "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.2.2", + "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" + } + }, + "finalhandler": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/finalhandler/-/finalhandler-1.0.4.tgz", + "integrity": "sha512-16l/r8RgzlXKmFOhZpHBztvye+lAhC5SU7hXavnerC9UfZqZxxXl3BzL8MhffPT3kF61lj9Oav2LKEzh0ei7tg==", + "requires": { + "debug": "2.6.8", + "encodeurl": "1.0.1", + "escape-html": "1.0.3", + "on-finished": "2.3.0", + "parseurl": "1.3.1", + "statuses": "1.3.1", + "unpipe": "1.0.0" + } + }, + "find-up": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/find-up/-/find-up-1.1.2.tgz", + "integrity": "sha1-ay6YIrGizgpgq2TWEOzK1TyyTQ8=", + "dev": true, + "requires": { + "path-exists": "2.1.0", + "pinkie-promise": "2.0.1" + } + }, + "flat-cache": { + "version": "1.2.2", + "resolved": "https://registry.npmjs.org/flat-cache/-/flat-cache-1.2.2.tgz", + "integrity": "sha1-+oZxTnLCHbiGAXYezy9VXRq8a5Y=", + "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" + } + }, + "forwarded": { + "version": "0.1.0", + "resolved": "https://registry.npmjs.org/forwarded/-/forwarded-0.1.0.tgz", + "integrity": "sha1-Ge+YdMSuHCl7zweP3mOgm2aoQ2M=" + }, + "fresh": { + "version": "0.5.0", + "resolved": "https://registry.npmjs.org/fresh/-/fresh-0.5.0.tgz", + "integrity": "sha1-9HTKXmqSRtb9jglTz6m5yAWvp44=" + }, + "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 + }, + "fsevents": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-1.1.2.tgz", + "integrity": "sha512-Sn44E5wQW4bTHXvQmvSHwqbuiXtduD6Rrjm2ZtUEGbyrig+nUH3t/QD4M4/ZXViY556TBpRgZkHLDx3JxPwxiw==", + "dev": true, + "optional": true, + "requires": { + "nan": "2.7.0", + "node-pre-gyp": "0.6.36" + }, + "dependencies": { + "abbrev": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/abbrev/-/abbrev-1.1.0.tgz", + "integrity": "sha1-0FVMIlZjbi9W58LlrRg/hZQo2B8=", + "dev": true, + "optional": true + }, + "ajv": { + "version": "4.11.8", + "resolved": "https://registry.npmjs.org/ajv/-/ajv-4.11.8.tgz", + "integrity": "sha1-gv+wKynmYq5TvcIK8VlHcGc5xTY=", + "dev": true, + "optional": true, + "requires": { + "co": "4.6.0", + "json-stable-stringify": "1.0.1" + } + }, + "ansi-regex": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-2.1.1.tgz", + "integrity": "sha1-w7M6te42DYbg5ijwRorn7yfWVN8=", + "dev": true + }, + "aproba": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/aproba/-/aproba-1.1.1.tgz", + "integrity": "sha1-ldNgDwdxCqDpKYxyatXs8urLq6s=", + "dev": true, + "optional": true + }, + "are-we-there-yet": { + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/are-we-there-yet/-/are-we-there-yet-1.1.4.tgz", + "integrity": "sha1-u13KOCu5TwXhUZQ3PRb9O6HKEQ0=", + "dev": true, + "optional": true, + "requires": { + "delegates": "1.0.0", + "readable-stream": "2.2.9" + } + }, + "asn1": { + "version": "0.2.3", + "resolved": "https://registry.npmjs.org/asn1/-/asn1-0.2.3.tgz", + "integrity": "sha1-2sh4dxPJlmhJ/IGAd36+nB3fO4Y=", + "dev": true, + "optional": true + }, + "assert-plus": { + "version": "0.2.0", + "resolved": "https://registry.npmjs.org/assert-plus/-/assert-plus-0.2.0.tgz", + "integrity": "sha1-104bh+ev/A24qttwIfP+SBAasjQ=", + "dev": true, + "optional": true + }, + "asynckit": { + "version": "0.4.0", + "resolved": "https://registry.npmjs.org/asynckit/-/asynckit-0.4.0.tgz", + "integrity": "sha1-x57Zf380y48robyXkLzDZkdLS3k=", + "dev": true, + "optional": true + }, + "aws-sign2": { + "version": "0.6.0", + "resolved": "https://registry.npmjs.org/aws-sign2/-/aws-sign2-0.6.0.tgz", + "integrity": "sha1-FDQt0428yU0OW4fXY81jYSwOeU8=", + "dev": true, + "optional": true + }, + "aws4": { + "version": "1.6.0", + "resolved": "https://registry.npmjs.org/aws4/-/aws4-1.6.0.tgz", + "integrity": "sha1-g+9cqGCysy5KDe7e6MdxudtXRx4=", + "dev": true, + "optional": true + }, + "balanced-match": { + "version": "0.4.2", + "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-0.4.2.tgz", + "integrity": "sha1-yz8+PHMtwPAe5wtAPzAuYddwmDg=", + "dev": true + }, + "bcrypt-pbkdf": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/bcrypt-pbkdf/-/bcrypt-pbkdf-1.0.1.tgz", + "integrity": "sha1-Y7xdy2EzG5K8Bf1SiVPDNGKgb40=", + "dev": true, + "optional": true, + "requires": { + "tweetnacl": "0.14.5" + } + }, + "block-stream": { + "version": "0.0.9", + "resolved": "https://registry.npmjs.org/block-stream/-/block-stream-0.0.9.tgz", + "integrity": "sha1-E+v+d4oDIFz+A3UUgeu0szAMEmo=", + "dev": true, + "requires": { + "inherits": "2.0.3" + } + }, + "boom": { + "version": "2.10.1", + "resolved": "https://registry.npmjs.org/boom/-/boom-2.10.1.tgz", + "integrity": "sha1-OciRjO/1eZ+D+UkqhI9iWt0Mdm8=", + "dev": true, + "requires": { + "hoek": "2.16.3" + } + }, + "brace-expansion": { + "version": "1.1.7", + "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.7.tgz", + "integrity": "sha1-Pv/DxQ4ABTH7cg6v+A8K6O8jz1k=", + "dev": true, + "requires": { + "balanced-match": "0.4.2", + "concat-map": "0.0.1" + } + }, + "buffer-shims": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/buffer-shims/-/buffer-shims-1.0.0.tgz", + "integrity": "sha1-mXjOMXOIxkmth5MCjDR37wRKi1E=", + "dev": true + }, + "caseless": { + "version": "0.12.0", + "resolved": "https://registry.npmjs.org/caseless/-/caseless-0.12.0.tgz", + "integrity": "sha1-G2gcIf+EAzyCZUMJBolCDRhxUdw=", + "dev": true, + "optional": true + }, + "co": { + "version": "4.6.0", + "resolved": "https://registry.npmjs.org/co/-/co-4.6.0.tgz", + "integrity": "sha1-bqa989hTrlTMuOR7+gvz+QMfsYQ=", + "dev": true, + "optional": 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 + }, + "combined-stream": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/combined-stream/-/combined-stream-1.0.5.tgz", + "integrity": "sha1-k4NwpXtKUd6ix3wV1cX9+JUWQAk=", + "dev": true, + "requires": { + "delayed-stream": "1.0.0" + } + }, + "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 + }, + "console-control-strings": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/console-control-strings/-/console-control-strings-1.1.0.tgz", + "integrity": "sha1-PXz0Rk22RG6mRL9LOVB/mFEAjo4=", + "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 + }, + "cryptiles": { + "version": "2.0.5", + "resolved": "https://registry.npmjs.org/cryptiles/-/cryptiles-2.0.5.tgz", + "integrity": "sha1-O9/s3GCBR8HGcgL6KR59ylnqo7g=", + "dev": true, + "optional": true, + "requires": { + "boom": "2.10.1" + } + }, + "dashdash": { + "version": "1.14.1", + "resolved": "https://registry.npmjs.org/dashdash/-/dashdash-1.14.1.tgz", + "integrity": "sha1-hTz6D3y+L+1d4gMmuN1YEDX24vA=", + "dev": true, + "optional": true, + "requires": { + "assert-plus": "1.0.0" + }, + "dependencies": { + "assert-plus": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/assert-plus/-/assert-plus-1.0.0.tgz", + "integrity": "sha1-8S4PPF13sLHN2RRpQuTpbB5N1SU=", + "dev": true, + "optional": true + } + } + }, + "debug": { + "version": "2.6.8", + "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.8.tgz", + "integrity": "sha1-5zFTHKLt4n0YgiJCfaF4IdaP9Pw=", + "dev": true, + "optional": true, + "requires": { + "ms": "2.0.0" + } + }, + "deep-extend": { + "version": "0.4.2", + "resolved": "https://registry.npmjs.org/deep-extend/-/deep-extend-0.4.2.tgz", + "integrity": "sha1-SLaZwn4zS/ifEIkr5DL25MfTSn8=", + "dev": true, + "optional": true + }, + "delayed-stream": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/delayed-stream/-/delayed-stream-1.0.0.tgz", + "integrity": "sha1-3zrhmayt+31ECqrgsp4icrJOxhk=", + "dev": true + }, + "delegates": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/delegates/-/delegates-1.0.0.tgz", + "integrity": "sha1-hMbhWbgZBP3KWaDvRM2HDTElD5o=", + "dev": true, + "optional": true + }, + "ecc-jsbn": { + "version": "0.1.1", + "resolved": "https://registry.npmjs.org/ecc-jsbn/-/ecc-jsbn-0.1.1.tgz", + "integrity": "sha1-D8c6ntXw1Tw4GTOYUj735UN3dQU=", + "dev": true, + "optional": true, + "requires": { + "jsbn": "0.1.1" + } + }, + "extend": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/extend/-/extend-3.0.1.tgz", + "integrity": "sha1-p1Xqe8Gt/MWjHOfnYtuq3F5jZEQ=", + "dev": true, + "optional": true + }, + "extsprintf": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/extsprintf/-/extsprintf-1.0.2.tgz", + "integrity": "sha1-4QgOBljjALBilJkMxw4VAiNf1VA=", + "dev": true + }, + "forever-agent": { + "version": "0.6.1", + "resolved": "https://registry.npmjs.org/forever-agent/-/forever-agent-0.6.1.tgz", + "integrity": "sha1-+8cfDEGt6zf5bFd60e1C2P2sypE=", + "dev": true, + "optional": true + }, + "form-data": { + "version": "2.1.4", + "resolved": "https://registry.npmjs.org/form-data/-/form-data-2.1.4.tgz", + "integrity": "sha1-M8GDrPGTJ27KqYFDpp6Uv+4XUNE=", + "dev": true, + "optional": true, + "requires": { + "asynckit": "0.4.0", + "combined-stream": "1.0.5", + "mime-types": "2.1.15" + } + }, + "fs.realpath": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/fs.realpath/-/fs.realpath-1.0.0.tgz", + "integrity": "sha1-FQStJSMVjKpA20onh8sBQRmU6k8=", + "dev": true + }, + "fstream": { + "version": "1.0.11", + "resolved": "https://registry.npmjs.org/fstream/-/fstream-1.0.11.tgz", + "integrity": "sha1-XB+x8RdHcRTwYyoOtLcbPLD9MXE=", + "dev": true, + "requires": { + "graceful-fs": "4.1.11", + "inherits": "2.0.3", + "mkdirp": "0.5.1", + "rimraf": "2.6.1" + } + }, + "fstream-ignore": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/fstream-ignore/-/fstream-ignore-1.0.5.tgz", + "integrity": "sha1-nDHa40dnAY/h0kmyTa2mfQktoQU=", + "dev": true, + "optional": true, + "requires": { + "fstream": "1.0.11", + "inherits": "2.0.3", + "minimatch": "3.0.4" + } + }, + "gauge": { + "version": "2.7.4", + "resolved": "https://registry.npmjs.org/gauge/-/gauge-2.7.4.tgz", + "integrity": "sha1-LANAXHU4w51+s3sxcCLjJfsBi/c=", + "dev": true, + "optional": true, + "requires": { + "aproba": "1.1.1", + "console-control-strings": "1.1.0", + "has-unicode": "2.0.1", + "object-assign": "4.1.1", + "signal-exit": "3.0.2", + "string-width": "1.0.2", + "strip-ansi": "3.0.1", + "wide-align": "1.1.2" + } + }, + "getpass": { + "version": "0.1.7", + "resolved": "https://registry.npmjs.org/getpass/-/getpass-0.1.7.tgz", + "integrity": "sha1-Xv+OPmhNVprkyysSgmBOi6YhSfo=", + "dev": true, + "optional": true, + "requires": { + "assert-plus": "1.0.0" + }, + "dependencies": { + "assert-plus": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/assert-plus/-/assert-plus-1.0.0.tgz", + "integrity": "sha1-8S4PPF13sLHN2RRpQuTpbB5N1SU=", + "dev": true, + "optional": 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" + } + }, + "graceful-fs": { + "version": "4.1.11", + "resolved": "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.1.11.tgz", + "integrity": "sha1-Dovf5NHduIVNZOBOp8AOKgJuVlg=", + "dev": true + }, + "har-schema": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/har-schema/-/har-schema-1.0.5.tgz", + "integrity": "sha1-0mMTX0MwfALGAq/I/pWXDAFRNp4=", + "dev": true, + "optional": true + }, + "har-validator": { + "version": "4.2.1", + "resolved": "https://registry.npmjs.org/har-validator/-/har-validator-4.2.1.tgz", + "integrity": "sha1-M0gdDxu/9gDdID11gSpqX7oALio=", + "dev": true, + "optional": true, + "requires": { + "ajv": "4.11.8", + "har-schema": "1.0.5" + } + }, + "has-unicode": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/has-unicode/-/has-unicode-2.0.1.tgz", + "integrity": "sha1-4Ob+aijPUROIVeCG0Wkedx3iqLk=", + "dev": true, + "optional": true + }, + "hawk": { + "version": "3.1.3", + "resolved": "https://registry.npmjs.org/hawk/-/hawk-3.1.3.tgz", + "integrity": "sha1-B4REvXwWQLD+VA0sm3PVlnjo4cQ=", + "dev": true, + "optional": true, + "requires": { + "boom": "2.10.1", + "cryptiles": "2.0.5", + "hoek": "2.16.3", + "sntp": "1.0.9" + } + }, + "hoek": { + "version": "2.16.3", + "resolved": "https://registry.npmjs.org/hoek/-/hoek-2.16.3.tgz", + "integrity": "sha1-ILt0A9POo5jpHcRxCo/xuCdKJe0=", + "dev": true + }, + "http-signature": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/http-signature/-/http-signature-1.1.1.tgz", + "integrity": "sha1-33LiZwZs0Kxn+3at+OE0qPvPkb8=", + "dev": true, + "optional": true, + "requires": { + "assert-plus": "0.2.0", + "jsprim": "1.4.0", + "sshpk": "1.13.0" + } + }, + "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 + }, + "ini": { + "version": "1.3.4", + "resolved": "https://registry.npmjs.org/ini/-/ini-1.3.4.tgz", + "integrity": "sha1-BTfLedr1m1mhpRff9wbIbsA5Fi4=", + "dev": true, + "optional": true + }, + "is-fullwidth-code-point": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-1.0.0.tgz", + "integrity": "sha1-754xOG8DGn8NZDr4L95QxFfvAMs=", + "dev": true, + "requires": { + "number-is-nan": "1.0.1" + } + }, + "is-typedarray": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/is-typedarray/-/is-typedarray-1.0.0.tgz", + "integrity": "sha1-5HnICFjfDBsR3dppQPlgEfzaSpo=", + "dev": true, + "optional": true + }, + "isarray": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/isarray/-/isarray-1.0.0.tgz", + "integrity": "sha1-u5NdSFgsuhaMBoNJV6VKPgcSTxE=", + "dev": true + }, + "isstream": { + "version": "0.1.2", + "resolved": "https://registry.npmjs.org/isstream/-/isstream-0.1.2.tgz", + "integrity": "sha1-R+Y/evVa+m+S4VAOaQ64uFKcCZo=", + "dev": true, + "optional": true + }, + "jodid25519": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/jodid25519/-/jodid25519-1.0.2.tgz", + "integrity": "sha1-BtSRIlUJNBlHfUJWM2BuDpB4KWc=", + "dev": true, + "optional": true, + "requires": { + "jsbn": "0.1.1" + } + }, + "jsbn": { + "version": "0.1.1", + "resolved": "https://registry.npmjs.org/jsbn/-/jsbn-0.1.1.tgz", + "integrity": "sha1-peZUwuWi3rXyAdls77yoDA7y9RM=", + "dev": true, + "optional": true + }, + "json-schema": { + "version": "0.2.3", + "resolved": "https://registry.npmjs.org/json-schema/-/json-schema-0.2.3.tgz", + "integrity": "sha1-tIDIkuWaLwWVTOcnvT8qTogvnhM=", + "dev": true, + "optional": true + }, + "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, + "optional": true, + "requires": { + "jsonify": "0.0.0" + } + }, + "json-stringify-safe": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/json-stringify-safe/-/json-stringify-safe-5.0.1.tgz", + "integrity": "sha1-Epai1Y/UXxmg9s4B1lcB4sc1tus=", + "dev": true, + "optional": true + }, + "jsonify": { + "version": "0.0.0", + "resolved": "https://registry.npmjs.org/jsonify/-/jsonify-0.0.0.tgz", + "integrity": "sha1-LHS27kHZPKUbe1qu6PUDYx0lKnM=", + "dev": true, + "optional": true + }, + "jsprim": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/jsprim/-/jsprim-1.4.0.tgz", + "integrity": "sha1-o7h+QCmNjDgFUtjMdiigu5WiKRg=", + "dev": true, + "optional": true, + "requires": { + "assert-plus": "1.0.0", + "extsprintf": "1.0.2", + "json-schema": "0.2.3", + "verror": "1.3.6" + }, + "dependencies": { + "assert-plus": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/assert-plus/-/assert-plus-1.0.0.tgz", + "integrity": "sha1-8S4PPF13sLHN2RRpQuTpbB5N1SU=", + "dev": true, + "optional": true + } + } + }, + "mime-db": { + "version": "1.27.0", + "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.27.0.tgz", + "integrity": "sha1-gg9XIpa70g7CXtVeW13oaeVDbrE=", + "dev": true + }, + "mime-types": { + "version": "2.1.15", + "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-2.1.15.tgz", + "integrity": "sha1-pOv1BkCUVpI3uM9wBGd20J/JKu0=", + "dev": true, + "requires": { + "mime-db": "1.27.0" + } + }, + "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.7" + } + }, + "minimist": { + "version": "0.0.8", + "resolved": "https://registry.npmjs.org/minimist/-/minimist-0.0.8.tgz", + "integrity": "sha1-hX/Kv8M5fSYluCKCYuhqp6ARsF0=", + "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" + } + }, + "ms": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz", + "integrity": "sha1-VgiurfwAvmwpAd9fmGF4jeDVl8g=", + "dev": true, + "optional": true + }, + "node-pre-gyp": { + "version": "0.6.36", + "resolved": "https://registry.npmjs.org/node-pre-gyp/-/node-pre-gyp-0.6.36.tgz", + "integrity": "sha1-22BBEst04NR3VU6bUFsXq936t4Y=", + "dev": true, + "optional": true, + "requires": { + "mkdirp": "0.5.1", + "nopt": "4.0.1", + "npmlog": "4.1.0", + "rc": "1.2.1", + "request": "2.81.0", + "rimraf": "2.6.1", + "semver": "5.3.0", + "tar": "2.2.1", + "tar-pack": "3.4.0" + } + }, + "nopt": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/nopt/-/nopt-4.0.1.tgz", + "integrity": "sha1-0NRoWv1UFRk8jHUFYC0NF81kR00=", + "dev": true, + "optional": true, + "requires": { + "abbrev": "1.1.0", + "osenv": "0.1.4" + } + }, + "npmlog": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/npmlog/-/npmlog-4.1.0.tgz", + "integrity": "sha512-ocolIkZYZt8UveuiDS0yAkkIjid1o7lPG8cYm05yNYzBn8ykQtaiPMEGp8fY9tKdDgm8okpdKzkvu1y9hUYugA==", + "dev": true, + "optional": true, + "requires": { + "are-we-there-yet": "1.1.4", + "console-control-strings": "1.1.0", + "gauge": "2.7.4", + "set-blocking": "2.0.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 + }, + "oauth-sign": { + "version": "0.8.2", + "resolved": "https://registry.npmjs.org/oauth-sign/-/oauth-sign-0.8.2.tgz", + "integrity": "sha1-Rqarfwrq2N6unsBWV4C31O/rnUM=", + "dev": true, + "optional": 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, + "optional": true + }, + "once": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz", + "integrity": "sha1-WDsap3WWHUsROsF9nFC6753Xa9E=", + "dev": true, + "requires": { + "wrappy": "1.0.2" + } + }, + "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, + "optional": 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, + "optional": true + }, + "osenv": { + "version": "0.1.4", + "resolved": "https://registry.npmjs.org/osenv/-/osenv-0.1.4.tgz", + "integrity": "sha1-Qv5tWVPfBsgGS+bxdsPQWqqjRkQ=", + "dev": true, + "optional": true, + "requires": { + "os-homedir": "1.0.2", + "os-tmpdir": "1.0.2" + } + }, + "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 + }, + "performance-now": { + "version": "0.2.0", + "resolved": "https://registry.npmjs.org/performance-now/-/performance-now-0.2.0.tgz", + "integrity": "sha1-M+8wxcd9TqIcWlOGnZG1bY8lVeU=", + "dev": true, + "optional": 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 + }, + "punycode": { + "version": "1.4.1", + "resolved": "https://registry.npmjs.org/punycode/-/punycode-1.4.1.tgz", + "integrity": "sha1-wNWmOycYgArY4esPpSachN1BhF4=", + "dev": true, + "optional": true + }, + "qs": { + "version": "6.4.0", + "resolved": "https://registry.npmjs.org/qs/-/qs-6.4.0.tgz", + "integrity": "sha1-E+JtKK1rD/qpExLNO/cI7TUecjM=", + "dev": true, + "optional": true + }, + "rc": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/rc/-/rc-1.2.1.tgz", + "integrity": "sha1-LgPo5C7kULjLPc5lvhv4l04d/ZU=", + "dev": true, + "optional": true, + "requires": { + "deep-extend": "0.4.2", + "ini": "1.3.4", + "minimist": "1.2.0", + "strip-json-comments": "2.0.1" + }, + "dependencies": { + "minimist": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.0.tgz", + "integrity": "sha1-o1AIsg9BOD7sH7kU9M1d95omQoQ=", + "dev": true, + "optional": true + } + } + }, + "readable-stream": { + "version": "2.2.9", + "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-2.2.9.tgz", + "integrity": "sha1-z3jsb0ptHrQ9JkiMrJfwQudLf8g=", + "dev": true, + "requires": { + "buffer-shims": "1.0.0", + "core-util-is": "1.0.2", + "inherits": "2.0.3", + "isarray": "1.0.0", + "process-nextick-args": "1.0.7", + "string_decoder": "1.0.1", + "util-deprecate": "1.0.2" + } + }, + "request": { + "version": "2.81.0", + "resolved": "https://registry.npmjs.org/request/-/request-2.81.0.tgz", + "integrity": "sha1-xpKJRqDgbF+Nb4qTM0af/aRimKA=", + "dev": true, + "optional": true, + "requires": { + "aws-sign2": "0.6.0", + "aws4": "1.6.0", + "caseless": "0.12.0", + "combined-stream": "1.0.5", + "extend": "3.0.1", + "forever-agent": "0.6.1", + "form-data": "2.1.4", + "har-validator": "4.2.1", + "hawk": "3.1.3", + "http-signature": "1.1.1", + "is-typedarray": "1.0.0", + "isstream": "0.1.2", + "json-stringify-safe": "5.0.1", + "mime-types": "2.1.15", + "oauth-sign": "0.8.2", + "performance-now": "0.2.0", + "qs": "6.4.0", + "safe-buffer": "5.0.1", + "stringstream": "0.0.5", + "tough-cookie": "2.3.2", + "tunnel-agent": "0.6.0", + "uuid": "3.0.1" + } + }, + "rimraf": { + "version": "2.6.1", + "resolved": "https://registry.npmjs.org/rimraf/-/rimraf-2.6.1.tgz", + "integrity": "sha1-wjOOxkPfeht/5cVPqG9XQopV8z0=", + "dev": true, + "requires": { + "glob": "7.1.2" + } + }, + "safe-buffer": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.0.1.tgz", + "integrity": "sha1-0mPKVGls2KMGtcplUekt5XkY++c=", + "dev": true + }, + "semver": { + "version": "5.3.0", + "resolved": "https://registry.npmjs.org/semver/-/semver-5.3.0.tgz", + "integrity": "sha1-myzl094C0XxgEq0yaqa00M9U+U8=", + "dev": true, + "optional": true + }, + "set-blocking": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/set-blocking/-/set-blocking-2.0.0.tgz", + "integrity": "sha1-BF+XgtARrppoA93TgrJDkrPYkPc=", + "dev": true, + "optional": true + }, + "signal-exit": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-3.0.2.tgz", + "integrity": "sha1-tf3AjxKH6hF4Yo5BXiUTK3NkbG0=", + "dev": true, + "optional": true + }, + "sntp": { + "version": "1.0.9", + "resolved": "https://registry.npmjs.org/sntp/-/sntp-1.0.9.tgz", + "integrity": "sha1-ZUEYTMkK7qbG57NeJlkIJEPGYZg=", + "dev": true, + "optional": true, + "requires": { + "hoek": "2.16.3" + } + }, + "sshpk": { + "version": "1.13.0", + "resolved": "https://registry.npmjs.org/sshpk/-/sshpk-1.13.0.tgz", + "integrity": "sha1-/yo+T9BEl1Vf7Zezmg/YL6+zozw=", + "dev": true, + "optional": true, + "requires": { + "asn1": "0.2.3", + "assert-plus": "1.0.0", + "bcrypt-pbkdf": "1.0.1", + "dashdash": "1.14.1", + "ecc-jsbn": "0.1.1", + "getpass": "0.1.7", + "jodid25519": "1.0.2", + "jsbn": "0.1.1", + "tweetnacl": "0.14.5" + }, + "dependencies": { + "assert-plus": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/assert-plus/-/assert-plus-1.0.0.tgz", + "integrity": "sha1-8S4PPF13sLHN2RRpQuTpbB5N1SU=", + "dev": true, + "optional": true + } + } + }, + "string_decoder": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.0.1.tgz", + "integrity": "sha1-YuIA8DmVWmgQ2N8KM//A8BNmLZg=", + "dev": true, + "requires": { + "safe-buffer": "5.0.1" + } + }, + "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" + } + }, + "stringstream": { + "version": "0.0.5", + "resolved": "https://registry.npmjs.org/stringstream/-/stringstream-0.0.5.tgz", + "integrity": "sha1-TkhM1N5aC7vuGORjB3EKioFiGHg=", + "dev": true, + "optional": true + }, + "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" + } + }, + "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, + "optional": true + }, + "tar": { + "version": "2.2.1", + "resolved": "https://registry.npmjs.org/tar/-/tar-2.2.1.tgz", + "integrity": "sha1-jk0qJWwOIYXGsYrWlK7JaLg8sdE=", + "dev": true, + "requires": { + "block-stream": "0.0.9", + "fstream": "1.0.11", + "inherits": "2.0.3" + } + }, + "tar-pack": { + "version": "3.4.0", + "resolved": "https://registry.npmjs.org/tar-pack/-/tar-pack-3.4.0.tgz", + "integrity": "sha1-I74tf2cagzk3bL2wuP4/3r8xeYQ=", + "dev": true, + "optional": true, + "requires": { + "debug": "2.6.8", + "fstream": "1.0.11", + "fstream-ignore": "1.0.5", + "once": "1.4.0", + "readable-stream": "2.2.9", + "rimraf": "2.6.1", + "tar": "2.2.1", + "uid-number": "0.0.6" + } + }, + "tough-cookie": { + "version": "2.3.2", + "resolved": "https://registry.npmjs.org/tough-cookie/-/tough-cookie-2.3.2.tgz", + "integrity": "sha1-8IH3bkyFcg5sN6X6ztc3FQ2EByo=", + "dev": true, + "optional": true, + "requires": { + "punycode": "1.4.1" + } + }, + "tunnel-agent": { + "version": "0.6.0", + "resolved": "https://registry.npmjs.org/tunnel-agent/-/tunnel-agent-0.6.0.tgz", + "integrity": "sha1-J6XeoGs2sEoKmWZ3SykIaPD8QP0=", + "dev": true, + "optional": true, + "requires": { + "safe-buffer": "5.0.1" + } + }, + "tweetnacl": { + "version": "0.14.5", + "resolved": "https://registry.npmjs.org/tweetnacl/-/tweetnacl-0.14.5.tgz", + "integrity": "sha1-WuaBd/GS1EViadEIr6k/+HQ/T2Q=", + "dev": true, + "optional": true + }, + "uid-number": { + "version": "0.0.6", + "resolved": "https://registry.npmjs.org/uid-number/-/uid-number-0.0.6.tgz", + "integrity": "sha1-DqEOgDXo61uOREnwbaHHMGY7qoE=", + "dev": true, + "optional": 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 + }, + "uuid": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/uuid/-/uuid-3.0.1.tgz", + "integrity": "sha1-ZUS7ot/ajBzxfmKaOjBeK7H+5sE=", + "dev": true, + "optional": true + }, + "verror": { + "version": "1.3.6", + "resolved": "https://registry.npmjs.org/verror/-/verror-1.3.6.tgz", + "integrity": "sha1-z/XfEpRtKX0rqu+qJoniW+AcAFw=", + "dev": true, + "optional": true, + "requires": { + "extsprintf": "1.0.2" + } + }, + "wide-align": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/wide-align/-/wide-align-1.1.2.tgz", + "integrity": "sha512-ijDLlyQ7s6x1JgCLur53osjm/UXUYD9+0PbYKrBsYisYXzCxN+HC3mYDNy/dWdmf3AwqwU3CXwDCvsNgGK1S0w==", + "dev": true, + "optional": true, + "requires": { + "string-width": "1.0.2" + } + }, + "wrappy": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz", + "integrity": "sha1-tSQ9jz7BqjXxNkYFvA0QNuMKtp8=", + "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 + }, + "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" + } + }, + "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" + } + }, + "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" + } + }, + "got": { + "version": "3.3.1", + "resolved": "https://registry.npmjs.org/got/-/got-3.3.1.tgz", + "integrity": "sha1-5dDtSvVfw+701WAHdp2YGSvLLso=", + "dev": true, + "requires": { + "duplexify": "3.5.1", + "infinity-agent": "2.0.3", + "is-redirect": "1.0.0", + "is-stream": "1.1.0", + "lowercase-keys": "1.0.0", + "nested-error-stacks": "1.0.2", + "object-assign": "3.0.0", + "prepend-http": "1.0.4", + "read-all-stream": "3.1.0", + "timed-out": "2.0.0" + }, + "dependencies": { + "object-assign": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/object-assign/-/object-assign-3.0.0.tgz", + "integrity": "sha1-m+3VygiXlJvKR+f/QIBi1Un1h/I=", + "dev": true + } + } + }, + "graceful-fs": { + "version": "4.1.11", + "resolved": "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.1.11.tgz", + "integrity": "sha1-Dovf5NHduIVNZOBOp8AOKgJuVlg=", + "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-binary2": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/has-binary2/-/has-binary2-1.0.2.tgz", + "integrity": "sha1-6D26SfC5vk0CbSc2U1DZ8D9Uvpg=", + "requires": { + "isarray": "2.0.1" + }, + "dependencies": { + "isarray": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/isarray/-/isarray-2.0.1.tgz", + "integrity": "sha1-o32U7ZzaLVmGXJ92/llu4fM4dB4=" + } + } + }, + "has-cors": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/has-cors/-/has-cors-1.1.0.tgz", + "integrity": "sha1-XkdHk/fqmEPRu5nCPu9J/xJv/zk=" + }, + "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=" + }, + "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" + } + }, + "home-or-tmp": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/home-or-tmp/-/home-or-tmp-2.0.0.tgz", + "integrity": "sha1-42w/LSyufXRqhX440Y1fMqeILbg=", + "dev": true, + "requires": { + "os-homedir": "1.0.2", + "os-tmpdir": "1.0.2" + } + }, + "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 + }, + "http-errors": { + "version": "1.6.2", + "resolved": "https://registry.npmjs.org/http-errors/-/http-errors-1.6.2.tgz", + "integrity": "sha1-CgAsyFcHGSp+eUbO7cERVfYOxzY=", + "requires": { + "depd": "1.1.1", + "inherits": "2.0.3", + "setprototypeof": "1.0.3", + "statuses": "1.3.1" + } + }, + "http-proxy": { + "version": "1.16.2", + "resolved": "https://registry.npmjs.org/http-proxy/-/http-proxy-1.16.2.tgz", + "integrity": "sha1-Bt/ykpUr9k2+hHH6nfcwZtTzd0I=", + "requires": { + "eventemitter3": "1.2.0", + "requires-port": "1.0.0" + } + }, + "http-server": { + "version": "0.10.0", + "resolved": "https://registry.npmjs.org/http-server/-/http-server-0.10.0.tgz", + "integrity": "sha1-sqRGsWqduH7TxiK6m+sbCFsSNKc=", + "requires": { + "colors": "1.0.3", + "corser": "2.0.1", + "ecstatic": "2.2.1", + "http-proxy": "1.16.2", + "opener": "1.4.3", + "optimist": "0.6.1", + "portfinder": "1.0.13", + "union": "0.4.6" + } + }, + "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 + }, + "iconv-lite": { + "version": "0.4.18", + "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.4.18.tgz", + "integrity": "sha512-sr1ZQph3UwHTR0XftSbK85OvBbxe/abLGzEnPENCQwmHf7sck8Oyu4ob3LgBxWWxRoM+QszeUyl7jbqapu2TqA==", + "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 + }, + "ignore-by-default": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/ignore-by-default/-/ignore-by-default-1.0.1.tgz", + "integrity": "sha1-SMptcvbGo68Aqa1K5odr44ieKwk=", + "dev": true + }, + "imurmurhash": { + "version": "0.1.4", + "resolved": "https://registry.npmjs.org/imurmurhash/-/imurmurhash-0.1.4.tgz", + "integrity": "sha1-khi5srkoojixPcT7a21XbyMUU+o=", + "dev": true + }, + "indexof": { + "version": "0.0.1", + "resolved": "https://registry.npmjs.org/indexof/-/indexof-0.0.1.tgz", + "integrity": "sha1-gtwzbSMrkGIXnQWrMpOmYFn9Q10=" + }, + "infinity-agent": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/infinity-agent/-/infinity-agent-2.0.3.tgz", + "integrity": "sha1-ReDi/3qesDCyfWK3SzdEt6esQhY=", + "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=" + }, + "ini": { + "version": "1.3.4", + "resolved": "https://registry.npmjs.org/ini/-/ini-1.3.4.tgz", + "integrity": "sha1-BTfLedr1m1mhpRff9wbIbsA5Fi4=", + "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.2.3", + "resolved": "https://registry.npmjs.org/inquirer/-/inquirer-3.2.3.tgz", + "integrity": "sha512-Bc3KbimpDTOeQdDj18Ir/rlsGuhBSSNqdOnxaAuKhpkdnMMuKsEGbZD2v5KFF9oso2OU+BPh7+/u5obmFDRmWw==", + "dev": true, + "requires": { + "ansi-escapes": "2.0.0", + "chalk": "2.1.0", + "cli-cursor": "2.1.0", + "cli-width": "2.2.0", + "external-editor": "2.0.4", + "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" + }, + "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" + } + }, + "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" + } + }, + "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" + } + }, + "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" + } + } + } + }, + "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": { + "combine-source-map": "0.7.2", + "concat-stream": "1.5.2", + "is-buffer": "1.1.5", + "JSONStream": "1.3.1", + "lexical-scope": "1.2.0", + "process": "0.11.10", + "through2": "2.0.3", + "xtend": "4.0.1" + } + }, + "install": { + "version": "0.10.1", + "resolved": "https://registry.npmjs.org/install/-/install-0.10.1.tgz", + "integrity": "sha1-HHtTyN1zNe9TTCZI3ij1md8b3Zc=" + }, + "invariant": { + "version": "2.2.2", + "resolved": "https://registry.npmjs.org/invariant/-/invariant-2.2.2.tgz", + "integrity": "sha1-nh9WrArNtr8wMwbzOL47IErmA2A=", + "dev": true, + "requires": { + "loose-envify": "1.3.1" + } + }, + "ipaddr.js": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/ipaddr.js/-/ipaddr.js-1.4.0.tgz", + "integrity": "sha1-KWrKh4qCGBbluF0KKFqZvP9FgvA=" + }, + "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-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": "1.0.0", + "resolved": "https://registry.npmjs.org/is-extglob/-/is-extglob-1.0.0.tgz", + "integrity": "sha1-rEaBd8SUNAWgkvyPKXYMb/xiBsA=", + "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": "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" + } + }, + "is-npm": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/is-npm/-/is-npm-1.0.0.tgz", + "integrity": "sha1-8vtjpl5JBbQGyGBydloaTceTufQ=", + "dev": true + }, + "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-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-redirect": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/is-redirect/-/is-redirect-1.0.0.tgz", + "integrity": "sha1-HQPd7VO9jbDzDCbk+V02/HyH3CQ=", + "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 + }, + "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" + } + }, + "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.9.1", + "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-3.9.1.tgz", + "integrity": "sha512-CbcG379L1e+mWBnLvHWWeLs8GyV/EMw862uLI3c+GxVyDHWZcjZinwuBd3iW2pgxgIlksW/1vNJa4to+RvDOww==", + "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 + }, + "jsesc": { + "version": "0.5.0", + "resolved": "https://registry.npmjs.org/jsesc/-/jsesc-0.5.0.tgz", + "integrity": "sha1-597mbjXW/Bb3EP6R1c9p9w8IkR0=", + "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" + } + }, + "json5": { + "version": "0.5.1", + "resolved": "https://registry.npmjs.org/json5/-/json5-0.5.1.tgz", + "integrity": "sha1-Hq3nrMASA0rYTiOWdn6tn6VJWCE=", + "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 + }, + "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" + } + }, + "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 + } + } + }, + "latest-version": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/latest-version/-/latest-version-1.0.1.tgz", + "integrity": "sha1-cs/Ebj6NG+ZR4eu1Tqn26pbzdLs=", + "dev": true, + "requires": { + "package-json": "1.2.0" + } + }, + "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" + } + }, + "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" + } + }, + "locate-path": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-2.0.0.tgz", + "integrity": "sha1-K1aLJl7slExtnA3pw9u7ygNUzY4=", + "dev": true, + "requires": { + "p-locate": "2.0.0", + "path-exists": "3.0.0" + }, + "dependencies": { + "path-exists": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-3.0.0.tgz", + "integrity": "sha1-zg6+ql94yxiSXqfYENe1mwEP1RU=", + "dev": true + } + } + }, + "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._bindcallback": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/lodash._bindcallback/-/lodash._bindcallback-3.0.1.tgz", + "integrity": "sha1-5THCdkTPi1epnhftlbNcdIeJOS4=", + "dev": true + }, + "lodash._createassigner": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/lodash._createassigner/-/lodash._createassigner-3.1.1.tgz", + "integrity": "sha1-g4pbri/aymOsIt7o4Z+k5taXCxE=", + "dev": true, + "requires": { + "lodash._bindcallback": "3.0.1", + "lodash._isiterateecall": "3.0.9", + "lodash.restparam": "3.6.1" + } + }, + "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.assign": { + "version": "3.2.0", + "resolved": "https://registry.npmjs.org/lodash.assign/-/lodash.assign-3.2.0.tgz", + "integrity": "sha1-POnwI0tLIiPilrj6CsH+6OvKZPo=", + "dev": true, + "requires": { + "lodash._baseassign": "3.2.0", + "lodash._createassigner": "3.1.1", + "lodash.keys": "3.1.2" + } + }, + "lodash.cond": { + "version": "4.5.2", + "resolved": "https://registry.npmjs.org/lodash.cond/-/lodash.cond-4.5.2.tgz", + "integrity": "sha1-9HGh2khr5g9quVXRcRVSPdHSVdU=", + "dev": true + }, + "lodash.defaults": { + "version": "3.1.2", + "resolved": "https://registry.npmjs.org/lodash.defaults/-/lodash.defaults-3.1.2.tgz", + "integrity": "sha1-xzCLGNv4vJNy1wGnNJPGEZK9Liw=", + "dev": true, + "requires": { + "lodash.assign": "3.2.0", + "lodash.restparam": "3.6.1" + } + }, + "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 + }, + "lodash.restparam": { + "version": "3.6.1", + "resolved": "https://registry.npmjs.org/lodash.restparam/-/lodash.restparam-3.6.1.tgz", + "integrity": "sha1-k2pOMJ7zMKdkXtQUWYbIWuWyCAU=", + "dev": true + }, + "loose-envify": { + "version": "1.3.1", + "resolved": "https://registry.npmjs.org/loose-envify/-/loose-envify-1.3.1.tgz", + "integrity": "sha1-0aitM/qc4OcT1l/dCsi3SNR4yEg=", + "dev": true, + "requires": { + "js-tokens": "3.0.2" + } + }, + "lowercase-keys": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/lowercase-keys/-/lowercase-keys-1.0.0.tgz", + "integrity": "sha1-TjNms55/VFfjXxMkvfb4jQv8cwY=", + "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" + } + } + } + }, + "media-typer": { + "version": "0.3.0", + "resolved": "https://registry.npmjs.org/media-typer/-/media-typer-0.3.0.tgz", + "integrity": "sha1-hxDXrwqmJvj/+hzgAWhUUmMlV0g=" + }, + "merge-descriptors": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/merge-descriptors/-/merge-descriptors-1.0.1.tgz", + "integrity": "sha1-sAqqVW3YtEVoFQ7J0blT8/kMu2E=" + }, + "methods": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/methods/-/methods-1.1.2.tgz", + "integrity": "sha1-VSmk1nZUE07cxSZmVoNbD4Ua/O4=" + }, + "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" + } + }, + "miller-rabin": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/miller-rabin/-/miller-rabin-4.0.0.tgz", + "integrity": "sha1-SmL7HUKTPAVYOYL0xxb2+55sbT0=", + "dev": true, + "requires": { + "bn.js": "4.11.8", + "brorand": "1.1.0" + } + }, + "mime": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/mime/-/mime-1.4.0.tgz", + "integrity": "sha512-n9ChLv77+QQEapYz8lV+rIZAW3HhAPW2CXnzb1GN5uMkuczshwvkW7XPsbzU0ZQN3sP47Er2KVkp2p3KyqZKSQ==" + }, + "mime-db": { + "version": "1.30.0", + "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.30.0.tgz", + "integrity": "sha1-dMZD2i3Z1qRTmZY0ZbJtXKfXHwE=" + }, + "mime-types": { + "version": "2.1.17", + "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-2.1.17.tgz", + "integrity": "sha1-Cdejk/A+mVp5+K+Fe3Cp4KsWVXo=", + "requires": { + "mime-db": "1.30.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 + }, + "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=" + }, + "mkdirp": { + "version": "0.5.1", + "resolved": "https://registry.npmjs.org/mkdirp/-/mkdirp-0.5.1.tgz", + "integrity": "sha1-MAV0OOrGz3+MR2fzhkjWaX11yQM=", + "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=" + } + } + }, + "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": { + "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", + "JSONStream": "1.3.1", + "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=" + }, + "mute-stream": { + "version": "0.0.7", + "resolved": "https://registry.npmjs.org/mute-stream/-/mute-stream-0.0.7.tgz", + "integrity": "sha1-MHXOk7whuPq0PhvE2n6BFe0ee6s=", + "dev": true + }, + "nan": { + "version": "2.7.0", + "resolved": "https://registry.npmjs.org/nan/-/nan-2.7.0.tgz", + "integrity": "sha1-2Vv3IeyHfgjbJ27T/G63j5CDrUY=", + "dev": true, + "optional": 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 + }, + "negotiator": { + "version": "0.6.1", + "resolved": "https://registry.npmjs.org/negotiator/-/negotiator-0.6.1.tgz", + "integrity": "sha1-KzJxhOiZIQEXeyhWP7XnECrNDKk=" + }, + "nested-error-stacks": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/nested-error-stacks/-/nested-error-stacks-1.0.2.tgz", + "integrity": "sha1-GfYZWRUZ8JZ2mlupqG5u7sgjw88=", + "dev": true, + "requires": { + "inherits": "2.0.3" + } + }, + "nodemon": { + "version": "1.11.0", + "resolved": "https://registry.npmjs.org/nodemon/-/nodemon-1.11.0.tgz", + "integrity": "sha1-ImxWK9KnsT09dRi0mtSCijYj0Gw=", + "dev": true, + "requires": { + "chokidar": "1.7.0", + "debug": "2.6.8", + "es6-promise": "3.3.1", + "ignore-by-default": "1.0.1", + "lodash.defaults": "3.1.2", + "minimatch": "3.0.4", + "ps-tree": "1.1.0", + "touch": "1.0.0", + "undefsafe": "0.0.3", + "update-notifier": "0.5.0" + } + }, + "nopt": { + "version": "1.0.10", + "resolved": "https://registry.npmjs.org/nopt/-/nopt-1.0.10.tgz", + "integrity": "sha1-bd0hvSoxQXuScn3Vhfim83YI6+4=", + "dev": true, + "requires": { + "abbrev": "1.1.0" + } + }, + "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": "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" + } + }, + "npm": { + "version": "5.4.0", + "resolved": "https://registry.npmjs.org/npm/-/npm-5.4.0.tgz", + "integrity": "sha512-jw7Gq2dMM3RWBUaQmuJTB/dcZEiTL2c6VUrXvlWU/37SXR0GCCGysKfwQcjQerTmmrycIpfLZS2msHa26FsAKQ==", + "requires": { + "abbrev": "1.1.0", + "ansi-regex": "3.0.0", + "ansicolors": "0.3.2", + "ansistyles": "0.1.3", + "aproba": "1.1.2", + "archy": "1.0.0", + "bluebird": "3.5.0", + "cacache": "9.2.9", + "call-limit": "1.1.0", + "chownr": "1.0.1", + "cmd-shim": "2.0.2", + "columnify": "1.5.4", + "config-chain": "1.1.11", + "debuglog": "1.0.1", + "detect-indent": "5.0.0", + "dezalgo": "1.0.3", + "editor": "1.0.0", + "fs-vacuum": "1.2.10", + "fs-write-stream-atomic": "1.0.10", + "glob": "7.1.2", + "graceful-fs": "4.1.11", + "has-unicode": "2.0.1", + "hosted-git-info": "2.5.0", + "iferr": "0.1.5", + "imurmurhash": "0.1.4", + "inflight": "1.0.6", + "inherits": "2.0.3", + "ini": "1.3.4", + "init-package-json": "1.10.1", + "JSONStream": "1.3.1", + "lazy-property": "1.0.0", + "libnpx": "9.6.0", + "lockfile": "1.0.3", + "lodash._baseindexof": "3.1.0", + "lodash._baseuniq": "4.6.0", + "lodash._bindcallback": "3.0.1", + "lodash._cacheindexof": "3.0.2", + "lodash._createcache": "3.1.2", + "lodash._getnative": "3.9.1", + "lodash.clonedeep": "4.5.0", + "lodash.restparam": "3.6.1", + "lodash.union": "4.6.0", + "lodash.uniq": "4.5.0", + "lodash.without": "4.4.0", + "lru-cache": "4.1.1", + "meant": "1.0.0", + "mississippi": "1.3.0", + "mkdirp": "0.5.1", + "move-concurrently": "1.0.1", + "node-gyp": "3.6.2", + "nopt": "4.0.1", + "normalize-package-data": "2.4.0", + "npm-cache-filename": "1.0.2", + "npm-install-checks": "3.0.0", + "npm-lifecycle": "1.0.2", + "npm-package-arg": "5.1.2", + "npm-packlist": "1.1.8", + "npm-registry-client": "8.4.0", + "npm-user-validate": "1.0.0", + "npmlog": "4.1.2", + "once": "1.4.0", + "opener": "1.4.3", + "osenv": "0.1.4", + "pacote": "6.0.1", + "path-is-inside": "1.0.2", + "promise-inflight": "1.0.1", + "read": "1.0.7", + "read-cmd-shim": "1.0.1", + "read-installed": "4.0.3", + "read-package-json": "2.0.12", + "read-package-tree": "5.1.6", + "readable-stream": "2.3.3", + "readdir-scoped-modules": "1.0.2", + "request": "2.81.0", + "retry": "0.10.1", + "rimraf": "2.6.1", + "safe-buffer": "5.1.1", + "semver": "5.4.1", + "sha": "2.0.1", + "slide": "1.1.6", + "sorted-object": "2.0.1", + "sorted-union-stream": "2.1.3", + "ssri": "4.1.6", + "strip-ansi": "4.0.0", + "tar": "4.0.1", + "text-table": "0.2.0", + "uid-number": "0.0.6", + "umask": "1.1.0", + "unique-filename": "1.1.0", + "unpipe": "1.0.0", + "update-notifier": "2.2.0", + "uuid": "3.1.0", + "validate-npm-package-license": "3.0.1", + "validate-npm-package-name": "3.0.0", + "which": "1.3.0", + "worker-farm": "1.5.0", + "wrappy": "1.0.2", + "write-file-atomic": "2.3.0" + }, + "dependencies": { + "abbrev": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/abbrev/-/abbrev-1.1.0.tgz", + "integrity": "sha1-0FVMIlZjbi9W58LlrRg/hZQo2B8=" + }, + "ansi-regex": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-3.0.0.tgz", + "integrity": "sha1-7QMXwyIGT3lGbAKWa922Bas32Zg=" + }, + "ansicolors": { + "version": "0.3.2", + "resolved": "https://registry.npmjs.org/ansicolors/-/ansicolors-0.3.2.tgz", + "integrity": "sha1-ZlWX3oap/+Oqm/vmyuXG6kJrSXk=" + }, + "ansistyles": { + "version": "0.1.3", + "resolved": "https://registry.npmjs.org/ansistyles/-/ansistyles-0.1.3.tgz", + "integrity": "sha1-XeYEFb2gcbs3EnhUyGT0GyMlRTk=" + }, + "aproba": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/aproba/-/aproba-1.1.2.tgz", + "integrity": "sha512-ZpYajIfO0j2cOFTO955KUMIKNmj6zhX8kVztMAxFsDaMwz+9Z9SV0uou2pC9HJqcfpffOsjnbrDMvkNy+9RXPw==" + }, + "archy": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/archy/-/archy-1.0.0.tgz", + "integrity": "sha1-+cjBN1fMHde8N5rHeyxipcKGjEA=" + }, + "bluebird": { + "version": "3.5.0", + "resolved": "https://registry.npmjs.org/bluebird/-/bluebird-3.5.0.tgz", + "integrity": "sha1-eRQg1/VR7qKJdFOop3ZT+WYG1nw=" + }, + "cacache": { + "version": "9.2.9", + "resolved": "https://registry.npmjs.org/cacache/-/cacache-9.2.9.tgz", + "integrity": "sha512-ghg1j5OyTJ6qsrqU++dN23QiTDxb5AZCFGsF3oB+v9v/gY+F4X8L/0gdQMEjd+8Ot3D29M2etX5PKozHRn2JQw==", + "requires": { + "bluebird": "3.5.0", + "chownr": "1.0.1", + "glob": "7.1.2", + "graceful-fs": "4.1.11", + "lru-cache": "4.1.1", + "mississippi": "1.3.0", + "mkdirp": "0.5.1", + "move-concurrently": "1.0.1", + "promise-inflight": "1.0.1", + "rimraf": "2.6.1", + "ssri": "4.1.6", + "unique-filename": "1.1.0", + "y18n": "3.2.1" + }, + "dependencies": { + "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==", + "requires": { + "pseudomap": "1.0.2", + "yallist": "2.1.2" + }, + "dependencies": { + "pseudomap": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/pseudomap/-/pseudomap-1.0.2.tgz", + "integrity": "sha1-8FKijacOYYkX7wqKw0wa5aaChrM=" + }, + "yallist": { + "version": "2.1.2", + "resolved": "https://registry.npmjs.org/yallist/-/yallist-2.1.2.tgz", + "integrity": "sha1-HBH5IY8HYImkfdUS+TxmmaaoHVI=" + } + } + }, + "y18n": { + "version": "3.2.1", + "resolved": "https://registry.npmjs.org/y18n/-/y18n-3.2.1.tgz", + "integrity": "sha1-bRX7qITAhnnA136I53WegR4H+kE=" + } + } + }, + "call-limit": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/call-limit/-/call-limit-1.1.0.tgz", + "integrity": "sha1-b9YbA/PaQqLNDsK2DwK9DnGZH+o=" + }, + "chownr": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/chownr/-/chownr-1.0.1.tgz", + "integrity": "sha1-4qdQQqlVGQi+vSW4Uj1fl2nXkYE=" + }, + "cmd-shim": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/cmd-shim/-/cmd-shim-2.0.2.tgz", + "integrity": "sha1-b8vamUg6j9FdfTChlspp1oii79s=", + "requires": { + "graceful-fs": "4.1.11", + "mkdirp": "0.5.1" + } + }, + "columnify": { + "version": "1.5.4", + "resolved": "https://registry.npmjs.org/columnify/-/columnify-1.5.4.tgz", + "integrity": "sha1-Rzfd8ce2mop8NAVweC6UfuyOeLs=", + "requires": { + "strip-ansi": "3.0.1", + "wcwidth": "1.0.1" + }, + "dependencies": { + "strip-ansi": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-3.0.1.tgz", + "integrity": "sha1-ajhfuIU9lS1f8F0Oiq+UJ43GPc8=", + "requires": { + "ansi-regex": "2.1.1" + }, + "dependencies": { + "ansi-regex": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-2.1.1.tgz", + "integrity": "sha1-w7M6te42DYbg5ijwRorn7yfWVN8=" + } + } + }, + "wcwidth": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/wcwidth/-/wcwidth-1.0.1.tgz", + "integrity": "sha1-8LDc+RW8X/FSivrbLA4XtTLaL+g=", + "requires": { + "defaults": "1.0.3" + }, + "dependencies": { + "defaults": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/defaults/-/defaults-1.0.3.tgz", + "integrity": "sha1-xlYFHpgX2f8I7YgUd/P+QBnz730=", + "requires": { + "clone": "1.0.2" + }, + "dependencies": { + "clone": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/clone/-/clone-1.0.2.tgz", + "integrity": "sha1-Jgt6meux7f4kdTgXX3gyQ8sZ0Uk=" + } + } + } + } + } + } + }, + "config-chain": { + "version": "1.1.11", + "resolved": "https://registry.npmjs.org/config-chain/-/config-chain-1.1.11.tgz", + "integrity": "sha1-q6CXR9++TD5w52am5BWG4YWfxvI=", + "requires": { + "ini": "1.3.4", + "proto-list": "1.2.4" + }, + "dependencies": { + "proto-list": { + "version": "1.2.4", + "resolved": "https://registry.npmjs.org/proto-list/-/proto-list-1.2.4.tgz", + "integrity": "sha1-IS1b/hMYMGpCD2QCuOJv85ZHqEk=" + } + } + }, + "debuglog": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/debuglog/-/debuglog-1.0.1.tgz", + "integrity": "sha1-qiT/uaw9+aI1GDfPstJ5NgzXhJI=" + }, + "detect-indent": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/detect-indent/-/detect-indent-5.0.0.tgz", + "integrity": "sha1-OHHMCmoALow+Wzz38zYmRnXwa50=" + }, + "dezalgo": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/dezalgo/-/dezalgo-1.0.3.tgz", + "integrity": "sha1-f3Qt4Gb8dIvI24IFad3c5Jvw1FY=", + "requires": { + "asap": "2.0.5", + "wrappy": "1.0.2" + }, + "dependencies": { + "asap": { + "version": "2.0.5", + "resolved": "https://registry.npmjs.org/asap/-/asap-2.0.5.tgz", + "integrity": "sha1-UidltQw1EEkOUtfc/ghe+bqWlY8=" + } + } + }, + "editor": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/editor/-/editor-1.0.0.tgz", + "integrity": "sha1-YMf4e9YrzGqJT6jM1q+3gjok90I=" + }, + "fs-vacuum": { + "version": "1.2.10", + "resolved": "https://registry.npmjs.org/fs-vacuum/-/fs-vacuum-1.2.10.tgz", + "integrity": "sha1-t2Kb7AekAxolSP35n17PHMizHjY=", + "requires": { + "graceful-fs": "4.1.11", + "path-is-inside": "1.0.2", + "rimraf": "2.6.1" + } + }, + "fs-write-stream-atomic": { + "version": "1.0.10", + "resolved": "https://registry.npmjs.org/fs-write-stream-atomic/-/fs-write-stream-atomic-1.0.10.tgz", + "integrity": "sha1-tH31NJPvkR33VzHnCp3tAYnbQMk=", + "requires": { + "graceful-fs": "4.1.11", + "iferr": "0.1.5", + "imurmurhash": "0.1.4", + "readable-stream": "2.3.3" + } + }, + "glob": { + "version": "7.1.2", + "resolved": "https://registry.npmjs.org/glob/-/glob-7.1.2.tgz", + "integrity": "sha512-MJTUg1kjuLeQCJ+ccE4Vpa6kKVXkPYJ2mOCQyUuKLcLQsdrMCpBPUi8qVE6+YuaJkozeA9NusTAw3hLr8Xe5EQ==", + "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" + }, + "dependencies": { + "fs.realpath": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/fs.realpath/-/fs.realpath-1.0.0.tgz", + "integrity": "sha1-FQStJSMVjKpA20onh8sBQRmU6k8=" + }, + "minimatch": { + "version": "3.0.4", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.0.4.tgz", + "integrity": "sha512-yJHVQEhyqPLUTgt9B83PXu6W3rx4MvvHvSUvToogpwoGDOUQ+yDrR0HRot+yOCdCO7u4hX3pWft6kWBBcqh0UA==", + "requires": { + "brace-expansion": "1.1.8" + }, + "dependencies": { + "brace-expansion": { + "version": "1.1.8", + "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.8.tgz", + "integrity": "sha1-wHshHHyVLsH479Uad+8NHTmQopI=", + "requires": { + "balanced-match": "1.0.0", + "concat-map": "0.0.1" + }, + "dependencies": { + "balanced-match": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.0.tgz", + "integrity": "sha1-ibTRmasr7kneFk6gK4nORi1xt2c=" + }, + "concat-map": { + "version": "0.0.1", + "resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz", + "integrity": "sha1-2Klr13/Wjfd5OnMDajug1UBdR3s=" + } + } + } + } + }, + "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=" + } + } + }, + "graceful-fs": { + "version": "4.1.11", + "resolved": "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.1.11.tgz", + "integrity": "sha1-Dovf5NHduIVNZOBOp8AOKgJuVlg=" + }, + "has-unicode": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/has-unicode/-/has-unicode-2.0.1.tgz", + "integrity": "sha1-4Ob+aijPUROIVeCG0Wkedx3iqLk=" + }, + "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==" + }, + "iferr": { + "version": "0.1.5", + "resolved": "https://registry.npmjs.org/iferr/-/iferr-0.1.5.tgz", + "integrity": "sha1-xg7taebY/bazEEofy8ocGS3FtQE=" + }, + "imurmurhash": { + "version": "0.1.4", + "resolved": "https://registry.npmjs.org/imurmurhash/-/imurmurhash-0.1.4.tgz", + "integrity": "sha1-khi5srkoojixPcT7a21XbyMUU+o=" + }, + "inflight": { + "version": "1.0.6", + "resolved": "https://registry.npmjs.org/inflight/-/inflight-1.0.6.tgz", + "integrity": "sha1-Sb1jMdfQLQwJvJEKEHW6gWW1bfk=", + "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=" + }, + "ini": { + "version": "1.3.4", + "resolved": "https://registry.npmjs.org/ini/-/ini-1.3.4.tgz", + "integrity": "sha1-BTfLedr1m1mhpRff9wbIbsA5Fi4=" + }, + "init-package-json": { + "version": "1.10.1", + "resolved": "https://registry.npmjs.org/init-package-json/-/init-package-json-1.10.1.tgz", + "integrity": "sha1-zYc6FneWvvuZYSsodioLY5P9j2o=", + "requires": { + "glob": "7.1.2", + "npm-package-arg": "5.1.2", + "promzard": "0.3.0", + "read": "1.0.7", + "read-package-json": "2.0.12", + "semver": "5.4.1", + "validate-npm-package-license": "3.0.1", + "validate-npm-package-name": "3.0.0" + }, + "dependencies": { + "promzard": { + "version": "0.3.0", + "resolved": "https://registry.npmjs.org/promzard/-/promzard-0.3.0.tgz", + "integrity": "sha1-JqXW7ox97kyxIggwWs+5O6OCqe4=", + "requires": { + "read": "1.0.7" + } + } + } + }, + "JSONStream": { + "version": "1.3.1", + "resolved": "https://registry.npmjs.org/JSONStream/-/JSONStream-1.3.1.tgz", + "integrity": "sha1-cH92HgHa6eFvG8+TcDt4xwlmV5o=", + "requires": { + "jsonparse": "1.3.1", + "through": "2.3.8" + }, + "dependencies": { + "jsonparse": { + "version": "1.3.1", + "resolved": "https://registry.npmjs.org/jsonparse/-/jsonparse-1.3.1.tgz", + "integrity": "sha1-P02uSpH6wxX3EGL4UhzCOfE2YoA=" + }, + "through": { + "version": "2.3.8", + "resolved": "https://registry.npmjs.org/through/-/through-2.3.8.tgz", + "integrity": "sha1-DdTJ/6q8NXlgsbckEV1+Doai4fU=" + } + } + }, + "lazy-property": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/lazy-property/-/lazy-property-1.0.0.tgz", + "integrity": "sha1-hN3Es3Bnm6i9TNz6TAa0PVcREUc=" + }, + "libnpx": { + "version": "9.6.0", + "resolved": "https://registry.npmjs.org/libnpx/-/libnpx-9.6.0.tgz", + "integrity": "sha512-XyfUHtcxQPuQ/KEjdDzA8IHu/l26u5HuaZa41Y8zvk8IjT7ZkpGE2jFXQ5ozpOPFpUoip7lE9iJJzJpITS+zkQ==", + "requires": { + "dotenv": "4.0.0", + "npm-package-arg": "5.1.2", + "rimraf": "2.6.1", + "safe-buffer": "5.1.1", + "update-notifier": "2.2.0", + "which": "1.3.0", + "y18n": "3.2.1", + "yargs": "8.0.2" + }, + "dependencies": { + "dotenv": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/dotenv/-/dotenv-4.0.0.tgz", + "integrity": "sha1-hk7xN5rO1Vzm+V3r7NzhefegzR0=" + }, + "y18n": { + "version": "3.2.1", + "resolved": "https://registry.npmjs.org/y18n/-/y18n-3.2.1.tgz", + "integrity": "sha1-bRX7qITAhnnA136I53WegR4H+kE=" + }, + "yargs": { + "version": "8.0.2", + "resolved": "https://registry.npmjs.org/yargs/-/yargs-8.0.2.tgz", + "integrity": "sha1-YpmpBVsc78lp/355wdkY3Osiw2A=", + "requires": { + "camelcase": "4.1.0", + "cliui": "3.2.0", + "decamelize": "1.2.0", + "get-caller-file": "1.0.2", + "os-locale": "2.1.0", + "read-pkg-up": "2.0.0", + "require-directory": "2.1.1", + "require-main-filename": "1.0.1", + "set-blocking": "2.0.0", + "string-width": "2.1.1", + "which-module": "2.0.0", + "y18n": "3.2.1", + "yargs-parser": "7.0.0" + }, + "dependencies": { + "camelcase": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/camelcase/-/camelcase-4.1.0.tgz", + "integrity": "sha1-1UVjW+HjPFQmScaRc+Xeas+uNN0=" + }, + "cliui": { + "version": "3.2.0", + "resolved": "https://registry.npmjs.org/cliui/-/cliui-3.2.0.tgz", + "integrity": "sha1-EgYBU3qRbSmUD5NNo7SNWFo5IT0=", + "requires": { + "string-width": "1.0.2", + "strip-ansi": "3.0.1", + "wrap-ansi": "2.1.0" + }, + "dependencies": { + "string-width": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/string-width/-/string-width-1.0.2.tgz", + "integrity": "sha1-EYvfW4zcUaKn5w0hHgfisLmxB9M=", + "requires": { + "code-point-at": "1.1.0", + "is-fullwidth-code-point": "1.0.0", + "strip-ansi": "3.0.1" + }, + "dependencies": { + "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=" + }, + "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=", + "requires": { + "number-is-nan": "1.0.1" + }, + "dependencies": { + "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=" + } + } + } + } + }, + "strip-ansi": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-3.0.1.tgz", + "integrity": "sha1-ajhfuIU9lS1f8F0Oiq+UJ43GPc8=", + "requires": { + "ansi-regex": "2.1.1" + }, + "dependencies": { + "ansi-regex": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-2.1.1.tgz", + "integrity": "sha1-w7M6te42DYbg5ijwRorn7yfWVN8=" + } + } + }, + "wrap-ansi": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-2.1.0.tgz", + "integrity": "sha1-2Pw9KE3QV5T+hJc8rs3Rz4JP3YU=", + "requires": { + "string-width": "1.0.2", + "strip-ansi": "3.0.1" + } + } + } + }, + "decamelize": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/decamelize/-/decamelize-1.2.0.tgz", + "integrity": "sha1-9lNNFRSCabIDUue+4m9QH5oZEpA=" + }, + "get-caller-file": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/get-caller-file/-/get-caller-file-1.0.2.tgz", + "integrity": "sha1-9wLmMSfn4jHBYKgMFVSstw1QR+U=" + }, + "os-locale": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/os-locale/-/os-locale-2.1.0.tgz", + "integrity": "sha512-3sslG3zJbEYcaC4YVAvDorjGxc7tv6KVATnLPZONiljsUncvihe9BQoVCEs0RZ1kmf4Hk9OBqlZfJZWI4GanKA==", + "requires": { + "execa": "0.7.0", + "lcid": "1.0.0", + "mem": "1.1.0" + }, + "dependencies": { + "execa": { + "version": "0.7.0", + "resolved": "https://registry.npmjs.org/execa/-/execa-0.7.0.tgz", + "integrity": "sha1-lEvs00zEHuMqY6n68nrVpl/Fl3c=", + "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" + }, + "dependencies": { + "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=", + "requires": { + "lru-cache": "4.1.1", + "shebang-command": "1.2.0", + "which": "1.3.0" + }, + "dependencies": { + "shebang-command": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/shebang-command/-/shebang-command-1.2.0.tgz", + "integrity": "sha1-RKrGW2lbAzmJaMOfNj/uXer98eo=", + "requires": { + "shebang-regex": "1.0.0" + }, + "dependencies": { + "shebang-regex": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/shebang-regex/-/shebang-regex-1.0.0.tgz", + "integrity": "sha1-2kL0l0DAtC2yypcoVxyxkMmO/qM=" + } + } + } + } + }, + "get-stream": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/get-stream/-/get-stream-3.0.0.tgz", + "integrity": "sha1-jpQ9E1jcN1VQVOy+LtsFqhdO3hQ=" + }, + "is-stream": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/is-stream/-/is-stream-1.1.0.tgz", + "integrity": "sha1-EtSj3U5o4Lec6428hBc66A2RykQ=" + }, + "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=", + "requires": { + "path-key": "2.0.1" + }, + "dependencies": { + "path-key": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/path-key/-/path-key-2.0.1.tgz", + "integrity": "sha1-QRyttXTFoUDTpLGRDUDYDMn0C0A=" + } + } + }, + "p-finally": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/p-finally/-/p-finally-1.0.0.tgz", + "integrity": "sha1-P7z7FbiZpEEjs0ttzBi3JDNqLK4=" + }, + "signal-exit": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-3.0.2.tgz", + "integrity": "sha1-tf3AjxKH6hF4Yo5BXiUTK3NkbG0=" + }, + "strip-eof": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/strip-eof/-/strip-eof-1.0.0.tgz", + "integrity": "sha1-u0P/VZim6wXYm1n80SnJgzE2Br8=" + } + } + }, + "lcid": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/lcid/-/lcid-1.0.0.tgz", + "integrity": "sha1-MIrMr6C8SDo4Z7S28rlQYlHRuDU=", + "requires": { + "invert-kv": "1.0.0" + }, + "dependencies": { + "invert-kv": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/invert-kv/-/invert-kv-1.0.0.tgz", + "integrity": "sha1-EEqOSqym09jNFXqO+L+rLXo//bY=" + } + } + }, + "mem": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/mem/-/mem-1.1.0.tgz", + "integrity": "sha1-Xt1StIXKHZAP5kiVUFOZoN+kX3Y=", + "requires": { + "mimic-fn": "1.1.0" + }, + "dependencies": { + "mimic-fn": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/mimic-fn/-/mimic-fn-1.1.0.tgz", + "integrity": "sha1-5md4PZLonb00KBi1IwudYqZyrRg=" + } + } + } + } + }, + "read-pkg-up": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/read-pkg-up/-/read-pkg-up-2.0.0.tgz", + "integrity": "sha1-a3KoBImE4MQeeVEP1en6mbO1Sb4=", + "requires": { + "find-up": "2.1.0", + "read-pkg": "2.0.0" + }, + "dependencies": { + "find-up": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/find-up/-/find-up-2.1.0.tgz", + "integrity": "sha1-RdG35QbHF93UgndaK3eSCjwMV6c=", + "requires": { + "locate-path": "2.0.0" + }, + "dependencies": { + "locate-path": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-2.0.0.tgz", + "integrity": "sha1-K1aLJl7slExtnA3pw9u7ygNUzY4=", + "requires": { + "p-locate": "2.0.0", + "path-exists": "3.0.0" + }, + "dependencies": { + "p-locate": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-2.0.0.tgz", + "integrity": "sha1-IKAQOyIqcMj9OcwuWAaA893l7EM=", + "requires": { + "p-limit": "1.1.0" + }, + "dependencies": { + "p-limit": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-1.1.0.tgz", + "integrity": "sha1-sH/y2aXYi+yAYDWJWiurZqJ5iLw=" + } + } + }, + "path-exists": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-3.0.0.tgz", + "integrity": "sha1-zg6+ql94yxiSXqfYENe1mwEP1RU=" + } + } + } + } + }, + "read-pkg": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/read-pkg/-/read-pkg-2.0.0.tgz", + "integrity": "sha1-jvHAYjxqbbDcZxPEv6xGMysjaPg=", + "requires": { + "load-json-file": "2.0.0", + "normalize-package-data": "2.4.0", + "path-type": "2.0.0" + }, + "dependencies": { + "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=", + "requires": { + "graceful-fs": "4.1.11", + "parse-json": "2.2.0", + "pify": "2.3.0", + "strip-bom": "3.0.0" + }, + "dependencies": { + "parse-json": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/parse-json/-/parse-json-2.2.0.tgz", + "integrity": "sha1-9ID0BDTvgHQfhGkJn43qGPVaTck=", + "requires": { + "error-ex": "1.3.1" + }, + "dependencies": { + "error-ex": { + "version": "1.3.1", + "resolved": "https://registry.npmjs.org/error-ex/-/error-ex-1.3.1.tgz", + "integrity": "sha1-+FWobOYa3E6GIcPNoh56dhLDqNw=", + "requires": { + "is-arrayish": "0.2.1" + }, + "dependencies": { + "is-arrayish": { + "version": "0.2.1", + "resolved": "https://registry.npmjs.org/is-arrayish/-/is-arrayish-0.2.1.tgz", + "integrity": "sha1-d8mYQFJ6qOyxqLppe4BkWnqSap0=" + } + } + } + } + }, + "pify": { + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/pify/-/pify-2.3.0.tgz", + "integrity": "sha1-7RQaasBDqEnqWISY59yosVMw6Qw=" + }, + "strip-bom": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/strip-bom/-/strip-bom-3.0.0.tgz", + "integrity": "sha1-IzTBjpx1n3vdVv3vfprj1YjmjtM=" + } + } + }, + "path-type": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/path-type/-/path-type-2.0.0.tgz", + "integrity": "sha1-8BLMuEFbcJb8LaoQVMPXI4lZTHM=", + "requires": { + "pify": "2.3.0" + }, + "dependencies": { + "pify": { + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/pify/-/pify-2.3.0.tgz", + "integrity": "sha1-7RQaasBDqEnqWISY59yosVMw6Qw=" + } + } + } + } + } + } + }, + "require-directory": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/require-directory/-/require-directory-2.1.1.tgz", + "integrity": "sha1-jGStX9MNqxyXbiNE/+f3kqam30I=" + }, + "require-main-filename": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/require-main-filename/-/require-main-filename-1.0.1.tgz", + "integrity": "sha1-l/cXtp1IeE9fUmpsWqj/3aBVpNE=" + }, + "set-blocking": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/set-blocking/-/set-blocking-2.0.0.tgz", + "integrity": "sha1-BF+XgtARrppoA93TgrJDkrPYkPc=" + }, + "string-width": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/string-width/-/string-width-2.1.1.tgz", + "integrity": "sha512-nOqH59deCq9SRHlxq1Aw85Jnt4w6KvLKqWVik6oA9ZklXLNIOlqg4F2yrT1MVaTjAqvVwdfeZ7w7aCvJD7ugkw==", + "requires": { + "is-fullwidth-code-point": "2.0.0", + "strip-ansi": "4.0.0" + }, + "dependencies": { + "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=" + } + } + }, + "which-module": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/which-module/-/which-module-2.0.0.tgz", + "integrity": "sha1-2e8H3Od7mQK4o6j6SzHD4/fm6Ho=" + }, + "yargs-parser": { + "version": "7.0.0", + "resolved": "https://registry.npmjs.org/yargs-parser/-/yargs-parser-7.0.0.tgz", + "integrity": "sha1-jQrELxbqVd69MyyvTEA4s+P139k=", + "requires": { + "camelcase": "4.1.0" + } + } + } + } + } + }, + "lockfile": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/lockfile/-/lockfile-1.0.3.tgz", + "integrity": "sha1-Jjj8OaAzHpysGgS3F5mTHJxQ33k=" + }, + "lodash._baseindexof": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/lodash._baseindexof/-/lodash._baseindexof-3.1.0.tgz", + "integrity": "sha1-/lK1OhxnYeQmGNZU5KJXie1hgiw=" + }, + "lodash._baseuniq": { + "version": "4.6.0", + "resolved": "https://registry.npmjs.org/lodash._baseuniq/-/lodash._baseuniq-4.6.0.tgz", + "integrity": "sha1-DrtE5FaBSveQXGIS+iybLVG4Qeg=", + "requires": { + "lodash._createset": "4.0.3", + "lodash._root": "3.0.1" + }, + "dependencies": { + "lodash._createset": { + "version": "4.0.3", + "resolved": "https://registry.npmjs.org/lodash._createset/-/lodash._createset-4.0.3.tgz", + "integrity": "sha1-D0ZZ+7CddRlPqeK4imZE02PJ/iY=" + }, + "lodash._root": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/lodash._root/-/lodash._root-3.0.1.tgz", + "integrity": "sha1-+6HEUkwZ7ppfgTa0YJ8BfPTe1pI=" + } + } + }, + "lodash._bindcallback": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/lodash._bindcallback/-/lodash._bindcallback-3.0.1.tgz", + "integrity": "sha1-5THCdkTPi1epnhftlbNcdIeJOS4=" + }, + "lodash._cacheindexof": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/lodash._cacheindexof/-/lodash._cacheindexof-3.0.2.tgz", + "integrity": "sha1-PcaayCSY0u5ePOVgkbr9Ktx73pI=" + }, + "lodash._createcache": { + "version": "3.1.2", + "resolved": "https://registry.npmjs.org/lodash._createcache/-/lodash._createcache-3.1.2.tgz", + "integrity": "sha1-VtagZAF2JeeevKa4AY4XRAvc8JM=", + "requires": { + "lodash._getnative": "3.9.1" + } + }, + "lodash._getnative": { + "version": "3.9.1", + "resolved": "https://registry.npmjs.org/lodash._getnative/-/lodash._getnative-3.9.1.tgz", + "integrity": "sha1-VwvH3t5G1hzc3mh9ZdPuy6o6r/U=" + }, + "lodash.clonedeep": { + "version": "4.5.0", + "resolved": "https://registry.npmjs.org/lodash.clonedeep/-/lodash.clonedeep-4.5.0.tgz", + "integrity": "sha1-4j8/nE+Pvd6HJSnBBxhXoIblzO8=" + }, + "lodash.restparam": { + "version": "3.6.1", + "resolved": "https://registry.npmjs.org/lodash.restparam/-/lodash.restparam-3.6.1.tgz", + "integrity": "sha1-k2pOMJ7zMKdkXtQUWYbIWuWyCAU=" + }, + "lodash.union": { + "version": "4.6.0", + "resolved": "https://registry.npmjs.org/lodash.union/-/lodash.union-4.6.0.tgz", + "integrity": "sha1-SLtQiECfFvGCFmZkHETdGqrjzYg=" + }, + "lodash.uniq": { + "version": "4.5.0", + "resolved": "https://registry.npmjs.org/lodash.uniq/-/lodash.uniq-4.5.0.tgz", + "integrity": "sha1-0CJTc662Uq3BvILklFM5qEJ1R3M=" + }, + "lodash.without": { + "version": "4.4.0", + "resolved": "https://registry.npmjs.org/lodash.without/-/lodash.without-4.4.0.tgz", + "integrity": "sha1-PNRXSgC2e643OpS3SHcmQFB7eqw=" + }, + "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==", + "requires": { + "pseudomap": "1.0.2", + "yallist": "2.1.2" + }, + "dependencies": { + "pseudomap": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/pseudomap/-/pseudomap-1.0.2.tgz", + "integrity": "sha1-8FKijacOYYkX7wqKw0wa5aaChrM=" + }, + "yallist": { + "version": "2.1.2", + "resolved": "https://registry.npmjs.org/yallist/-/yallist-2.1.2.tgz", + "integrity": "sha1-HBH5IY8HYImkfdUS+TxmmaaoHVI=" + } + } + }, + "meant": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/meant/-/meant-1.0.0.tgz", + "integrity": "sha1-y2KG47evkxXxYRj9wiRybtOAdLs=" + }, + "mississippi": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/mississippi/-/mississippi-1.3.0.tgz", + "integrity": "sha1-0gFYPrEjJ+PFwWQqQEqcrPlONPU=", + "requires": { + "concat-stream": "1.6.0", + "duplexify": "3.5.0", + "end-of-stream": "1.4.0", + "flush-write-stream": "1.0.2", + "from2": "2.3.0", + "parallel-transform": "1.1.0", + "pump": "1.0.2", + "pumpify": "1.3.5", + "stream-each": "1.2.0", + "through2": "2.0.3" + }, + "dependencies": { + "concat-stream": { + "version": "1.6.0", + "resolved": "https://registry.npmjs.org/concat-stream/-/concat-stream-1.6.0.tgz", + "integrity": "sha1-CqxmL9Ur54lk1VMvaUeE5wEQrPc=", + "requires": { + "inherits": "2.0.3", + "readable-stream": "2.3.3", + "typedarray": "0.0.6" + }, + "dependencies": { + "typedarray": { + "version": "0.0.6", + "resolved": "https://registry.npmjs.org/typedarray/-/typedarray-0.0.6.tgz", + "integrity": "sha1-hnrHTjhkGHsdPUfZlqeOxciDB3c=" + } + } + }, + "duplexify": { + "version": "3.5.0", + "resolved": "https://registry.npmjs.org/duplexify/-/duplexify-3.5.0.tgz", + "integrity": "sha1-GqdzAC4VeEV+nZ1KULDMquvL1gQ=", + "requires": { + "end-of-stream": "1.0.0", + "inherits": "2.0.3", + "readable-stream": "2.3.3", + "stream-shift": "1.0.0" + }, + "dependencies": { + "end-of-stream": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/end-of-stream/-/end-of-stream-1.0.0.tgz", + "integrity": "sha1-1FlucCc0qT5A6a+GQxnqvZn/Lw4=", + "requires": { + "once": "1.3.3" + }, + "dependencies": { + "once": { + "version": "1.3.3", + "resolved": "https://registry.npmjs.org/once/-/once-1.3.3.tgz", + "integrity": "sha1-suJhVXzkwxTsgwTz+oJmPkKXyiA=", + "requires": { + "wrappy": "1.0.2" + } + } + } + }, + "stream-shift": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/stream-shift/-/stream-shift-1.0.0.tgz", + "integrity": "sha1-1cdSgl5TZ+eG944Y5EXqIjoVWVI=" + } + } + }, + "end-of-stream": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/end-of-stream/-/end-of-stream-1.4.0.tgz", + "integrity": "sha1-epDYM+/abPpurA9JSduw+tOmMgY=", + "requires": { + "once": "1.4.0" + } + }, + "flush-write-stream": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/flush-write-stream/-/flush-write-stream-1.0.2.tgz", + "integrity": "sha1-yBuQ2HRnZvGmCaRoCZRsRd2K5Bc=", + "requires": { + "inherits": "2.0.3", + "readable-stream": "2.3.3" + } + }, + "from2": { + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/from2/-/from2-2.3.0.tgz", + "integrity": "sha1-i/tVAr3kpNNs/e6gB/zKIdfjgq8=", + "requires": { + "inherits": "2.0.3", + "readable-stream": "2.3.3" + } + }, + "parallel-transform": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/parallel-transform/-/parallel-transform-1.1.0.tgz", + "integrity": "sha1-1BDwZbBdojCB/NEPKIVMKb2jOwY=", + "requires": { + "cyclist": "0.2.2", + "inherits": "2.0.3", + "readable-stream": "2.3.3" + }, + "dependencies": { + "cyclist": { + "version": "0.2.2", + "resolved": "https://registry.npmjs.org/cyclist/-/cyclist-0.2.2.tgz", + "integrity": "sha1-GzN5LhHpFKL9bW7WRHRkRE5fpkA=" + } + } + }, + "pump": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/pump/-/pump-1.0.2.tgz", + "integrity": "sha1-Oz7mUS+U8OV1U4wXmV+fFpkKXVE=", + "requires": { + "end-of-stream": "1.4.0", + "once": "1.4.0" + } + }, + "pumpify": { + "version": "1.3.5", + "resolved": "https://registry.npmjs.org/pumpify/-/pumpify-1.3.5.tgz", + "integrity": "sha1-G2ccYZlAq8rqwK0OOjwWS+dgmTs=", + "requires": { + "duplexify": "3.5.0", + "inherits": "2.0.3", + "pump": "1.0.2" + } + }, + "stream-each": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/stream-each/-/stream-each-1.2.0.tgz", + "integrity": "sha1-HpXUdXP1gNgU3A/4zQ9m8c5TyZE=", + "requires": { + "end-of-stream": "1.4.0", + "stream-shift": "1.0.0" + }, + "dependencies": { + "stream-shift": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/stream-shift/-/stream-shift-1.0.0.tgz", + "integrity": "sha1-1cdSgl5TZ+eG944Y5EXqIjoVWVI=" + } + } + }, + "through2": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/through2/-/through2-2.0.3.tgz", + "integrity": "sha1-AARWmzfHx0ujnEPzzteNGtlBQL4=", + "requires": { + "readable-stream": "2.3.3", + "xtend": "4.0.1" + }, + "dependencies": { + "xtend": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/xtend/-/xtend-4.0.1.tgz", + "integrity": "sha1-pcbVMr5lbiPbgg77lDofBJmNY68=" + } + } + } + } + }, + "mkdirp": { + "version": "0.5.1", + "resolved": "https://registry.npmjs.org/mkdirp/-/mkdirp-0.5.1.tgz", + "integrity": "sha1-MAV0OOrGz3+MR2fzhkjWaX11yQM=", + "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=" + } + } + }, + "move-concurrently": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/move-concurrently/-/move-concurrently-1.0.1.tgz", + "integrity": "sha1-viwAX9oy4LKa8fBdfEszIUxwH5I=", + "requires": { + "aproba": "1.1.2", + "copy-concurrently": "1.0.3", + "fs-write-stream-atomic": "1.0.10", + "mkdirp": "0.5.1", + "rimraf": "2.6.1", + "run-queue": "1.0.3" + }, + "dependencies": { + "copy-concurrently": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/copy-concurrently/-/copy-concurrently-1.0.3.tgz", + "integrity": "sha1-Rft4ZiSaHKiJqlcI5svSc+dbslA=", + "requires": { + "aproba": "1.1.2", + "fs-write-stream-atomic": "1.0.10", + "iferr": "0.1.5", + "mkdirp": "0.5.1", + "rimraf": "2.6.1", + "run-queue": "1.0.3" + } + }, + "run-queue": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/run-queue/-/run-queue-1.0.3.tgz", + "integrity": "sha1-6Eg5bwV9Ij8kOGkkYY4laUFh7Ec=", + "requires": { + "aproba": "1.1.2" + } + } + } + }, + "node-gyp": { + "version": "3.6.2", + "resolved": "https://registry.npmjs.org/node-gyp/-/node-gyp-3.6.2.tgz", + "integrity": "sha1-m/vlRWIoYoSDjnUOrAUpWFP6HGA=", + "requires": { + "fstream": "1.0.11", + "glob": "7.1.2", + "graceful-fs": "4.1.11", + "minimatch": "3.0.4", + "mkdirp": "0.5.1", + "nopt": "3.0.6", + "npmlog": "4.1.2", + "osenv": "0.1.4", + "request": "2.81.0", + "rimraf": "2.6.1", + "semver": "5.3.0", + "tar": "2.2.1", + "which": "1.3.0" + }, + "dependencies": { + "fstream": { + "version": "1.0.11", + "resolved": "https://registry.npmjs.org/fstream/-/fstream-1.0.11.tgz", + "integrity": "sha1-XB+x8RdHcRTwYyoOtLcbPLD9MXE=", + "requires": { + "graceful-fs": "4.1.11", + "inherits": "2.0.3", + "mkdirp": "0.5.1", + "rimraf": "2.6.1" + } + }, + "minimatch": { + "version": "3.0.4", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.0.4.tgz", + "integrity": "sha512-yJHVQEhyqPLUTgt9B83PXu6W3rx4MvvHvSUvToogpwoGDOUQ+yDrR0HRot+yOCdCO7u4hX3pWft6kWBBcqh0UA==", + "requires": { + "brace-expansion": "1.1.8" + }, + "dependencies": { + "brace-expansion": { + "version": "1.1.8", + "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.8.tgz", + "integrity": "sha1-wHshHHyVLsH479Uad+8NHTmQopI=", + "requires": { + "balanced-match": "1.0.0", + "concat-map": "0.0.1" + }, + "dependencies": { + "balanced-match": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.0.tgz", + "integrity": "sha1-ibTRmasr7kneFk6gK4nORi1xt2c=" + }, + "concat-map": { + "version": "0.0.1", + "resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz", + "integrity": "sha1-2Klr13/Wjfd5OnMDajug1UBdR3s=" + } + } + } + } + }, + "nopt": { + "version": "3.0.6", + "resolved": "https://registry.npmjs.org/nopt/-/nopt-3.0.6.tgz", + "integrity": "sha1-xkZdvwirzU2zWTF/eaxopkayj/k=", + "requires": { + "abbrev": "1.1.0" + } + }, + "semver": { + "version": "5.3.0", + "resolved": "https://registry.npmjs.org/semver/-/semver-5.3.0.tgz", + "integrity": "sha1-myzl094C0XxgEq0yaqa00M9U+U8=" + }, + "tar": { + "version": "2.2.1", + "resolved": "https://registry.npmjs.org/tar/-/tar-2.2.1.tgz", + "integrity": "sha1-jk0qJWwOIYXGsYrWlK7JaLg8sdE=", + "requires": { + "block-stream": "0.0.9", + "fstream": "1.0.11", + "inherits": "2.0.3" + }, + "dependencies": { + "block-stream": { + "version": "0.0.9", + "resolved": "https://registry.npmjs.org/block-stream/-/block-stream-0.0.9.tgz", + "integrity": "sha1-E+v+d4oDIFz+A3UUgeu0szAMEmo=", + "requires": { + "inherits": "2.0.3" + } + } + } + } + } + }, + "nopt": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/nopt/-/nopt-4.0.1.tgz", + "integrity": "sha1-0NRoWv1UFRk8jHUFYC0NF81kR00=", + "requires": { + "abbrev": "1.1.0", + "osenv": "0.1.4" + } + }, + "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==", + "requires": { + "hosted-git-info": "2.5.0", + "is-builtin-module": "1.0.0", + "semver": "5.4.1", + "validate-npm-package-license": "3.0.1" + }, + "dependencies": { + "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=", + "requires": { + "builtin-modules": "1.1.1" + }, + "dependencies": { + "builtin-modules": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/builtin-modules/-/builtin-modules-1.1.1.tgz", + "integrity": "sha1-Jw8HbFpywC9bZaR9+Uxf46J4iS8=" + } + } + } + } + }, + "npm-cache-filename": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/npm-cache-filename/-/npm-cache-filename-1.0.2.tgz", + "integrity": "sha1-3tMGxbC/yHCp6fr4I7xfKD4FrhE=" + }, + "npm-install-checks": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/npm-install-checks/-/npm-install-checks-3.0.0.tgz", + "integrity": "sha1-1K7N/VGlPjcjt7L5Oy7ijjB7wNc=", + "requires": { + "semver": "5.4.1" + } + }, + "npm-lifecycle": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/npm-lifecycle/-/npm-lifecycle-1.0.2.tgz", + "integrity": "sha512-tuSfwKmTiJMVeQdvAfYJ1I+sC6tTpN2W6UWuHPkCy4FtM29Oc+DsuMDdTSaJTmbTairCtx9gXPI8DqZL42GF5g==", + "requires": { + "graceful-fs": "4.1.11", + "slide": "1.1.6", + "uid-number": "0.0.6", + "umask": "1.1.0", + "which": "1.3.0" + } + }, + "npm-package-arg": { + "version": "5.1.2", + "resolved": "https://registry.npmjs.org/npm-package-arg/-/npm-package-arg-5.1.2.tgz", + "integrity": "sha512-wJBsrf0qpypPT7A0LART18hCdyhpCMxeTtcb0X4IZO2jsP6Om7EHN1d9KSKiqD+KVH030RVNpWS9thk+pb7wzA==", + "requires": { + "hosted-git-info": "2.5.0", + "osenv": "0.1.4", + "semver": "5.4.1", + "validate-npm-package-name": "3.0.0" + } + }, + "npm-packlist": { + "version": "1.1.8", + "resolved": "https://registry.npmjs.org/npm-packlist/-/npm-packlist-1.1.8.tgz", + "integrity": "sha512-ZF/1c80o8g+rbJoe898m3p/gpquP/UK92vuTIw4wIVmoBZhRPGCPu8p+DJFV5MOa+HUT7CKVp+g9Hz+ayGW/+A==", + "requires": { + "ignore-walk": "3.0.0", + "npm-bundled": "1.0.3" + }, + "dependencies": { + "ignore-walk": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/ignore-walk/-/ignore-walk-3.0.0.tgz", + "integrity": "sha512-tKHrQ70YReq6IFyAs/XAQy91mgLVpLExNh3HrjExr6vqg8FLq/vd27D4eAN0K2PodhLjiQu5Xc2Q+AkW/T7hKQ==", + "requires": { + "minimatch": "3.0.4" + }, + "dependencies": { + "minimatch": { + "version": "3.0.4", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.0.4.tgz", + "integrity": "sha512-yJHVQEhyqPLUTgt9B83PXu6W3rx4MvvHvSUvToogpwoGDOUQ+yDrR0HRot+yOCdCO7u4hX3pWft6kWBBcqh0UA==", + "requires": { + "brace-expansion": "1.1.8" + }, + "dependencies": { + "brace-expansion": { + "version": "1.1.8", + "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.8.tgz", + "integrity": "sha1-wHshHHyVLsH479Uad+8NHTmQopI=", + "requires": { + "balanced-match": "1.0.0", + "concat-map": "0.0.1" + }, + "dependencies": { + "balanced-match": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.0.tgz", + "integrity": "sha1-ibTRmasr7kneFk6gK4nORi1xt2c=" + }, + "concat-map": { + "version": "0.0.1", + "resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz", + "integrity": "sha1-2Klr13/Wjfd5OnMDajug1UBdR3s=" + } + } + } + } + } + } + }, + "npm-bundled": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/npm-bundled/-/npm-bundled-1.0.3.tgz", + "integrity": "sha512-ByQ3oJ/5ETLyglU2+8dBObvhfWXX8dtPZDMePCahptliFX2iIuhyEszyFk401PZUNQH20vvdW5MLjJxkwU80Ow==" + } + } + }, + "npm-registry-client": { + "version": "8.4.0", + "resolved": "https://registry.npmjs.org/npm-registry-client/-/npm-registry-client-8.4.0.tgz", + "integrity": "sha512-PVNfqq0lyRdFnE//nDmn3CC9uqTsr8Bya9KPLIevlXMfkP0m4RpCVyFFk0W1Gfx436kKwyhLA6J+lV+rgR81gQ==", + "requires": { + "concat-stream": "1.6.0", + "graceful-fs": "4.1.11", + "normalize-package-data": "2.4.0", + "npm-package-arg": "5.1.2", + "npmlog": "4.1.2", + "once": "1.4.0", + "request": "2.81.0", + "retry": "0.10.1", + "semver": "5.4.1", + "slide": "1.1.6", + "ssri": "4.1.6" + }, + "dependencies": { + "concat-stream": { + "version": "1.6.0", + "resolved": "https://registry.npmjs.org/concat-stream/-/concat-stream-1.6.0.tgz", + "integrity": "sha1-CqxmL9Ur54lk1VMvaUeE5wEQrPc=", + "requires": { + "inherits": "2.0.3", + "readable-stream": "2.3.3", + "typedarray": "0.0.6" + }, + "dependencies": { + "typedarray": { + "version": "0.0.6", + "resolved": "https://registry.npmjs.org/typedarray/-/typedarray-0.0.6.tgz", + "integrity": "sha1-hnrHTjhkGHsdPUfZlqeOxciDB3c=" + } + } + } + } + }, + "npm-user-validate": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/npm-user-validate/-/npm-user-validate-1.0.0.tgz", + "integrity": "sha1-jOyg9c6gTU6TUZ73LQVXp1Ei6VE=" + }, + "npmlog": { + "version": "4.1.2", + "resolved": "https://registry.npmjs.org/npmlog/-/npmlog-4.1.2.tgz", + "integrity": "sha512-2uUqazuKlTaSI/dC8AzicUck7+IrEaOnN/e0jd3Xtt1KcGpwx30v50mL7oPyr/h9bL3E4aZccVwpwP+5W9Vjkg==", + "requires": { + "are-we-there-yet": "1.1.4", + "console-control-strings": "1.1.0", + "gauge": "2.7.4", + "set-blocking": "2.0.0" + }, + "dependencies": { + "are-we-there-yet": { + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/are-we-there-yet/-/are-we-there-yet-1.1.4.tgz", + "integrity": "sha1-u13KOCu5TwXhUZQ3PRb9O6HKEQ0=", + "requires": { + "delegates": "1.0.0", + "readable-stream": "2.3.3" + }, + "dependencies": { + "delegates": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/delegates/-/delegates-1.0.0.tgz", + "integrity": "sha1-hMbhWbgZBP3KWaDvRM2HDTElD5o=" + } + } + }, + "console-control-strings": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/console-control-strings/-/console-control-strings-1.1.0.tgz", + "integrity": "sha1-PXz0Rk22RG6mRL9LOVB/mFEAjo4=" + }, + "gauge": { + "version": "2.7.4", + "resolved": "https://registry.npmjs.org/gauge/-/gauge-2.7.4.tgz", + "integrity": "sha1-LANAXHU4w51+s3sxcCLjJfsBi/c=", + "requires": { + "aproba": "1.1.2", + "console-control-strings": "1.1.0", + "has-unicode": "2.0.1", + "object-assign": "4.1.1", + "signal-exit": "3.0.2", + "string-width": "1.0.2", + "strip-ansi": "3.0.1", + "wide-align": "1.1.2" + }, + "dependencies": { + "object-assign": { + "version": "4.1.1", + "resolved": "https://registry.npmjs.org/object-assign/-/object-assign-4.1.1.tgz", + "integrity": "sha1-IQmtx5ZYh8/AXLvUQsrIv7s2CGM=" + }, + "signal-exit": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-3.0.2.tgz", + "integrity": "sha1-tf3AjxKH6hF4Yo5BXiUTK3NkbG0=" + }, + "string-width": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/string-width/-/string-width-1.0.2.tgz", + "integrity": "sha1-EYvfW4zcUaKn5w0hHgfisLmxB9M=", + "requires": { + "code-point-at": "1.1.0", + "is-fullwidth-code-point": "1.0.0", + "strip-ansi": "3.0.1" + }, + "dependencies": { + "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=" + }, + "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=", + "requires": { + "number-is-nan": "1.0.1" + }, + "dependencies": { + "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=" + } + } + } + } + }, + "strip-ansi": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-3.0.1.tgz", + "integrity": "sha1-ajhfuIU9lS1f8F0Oiq+UJ43GPc8=", + "requires": { + "ansi-regex": "2.1.1" + }, + "dependencies": { + "ansi-regex": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-2.1.1.tgz", + "integrity": "sha1-w7M6te42DYbg5ijwRorn7yfWVN8=" + } + } + }, + "wide-align": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/wide-align/-/wide-align-1.1.2.tgz", + "integrity": "sha512-ijDLlyQ7s6x1JgCLur53osjm/UXUYD9+0PbYKrBsYisYXzCxN+HC3mYDNy/dWdmf3AwqwU3CXwDCvsNgGK1S0w==", + "requires": { + "string-width": "1.0.2" + } + } + } + }, + "set-blocking": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/set-blocking/-/set-blocking-2.0.0.tgz", + "integrity": "sha1-BF+XgtARrppoA93TgrJDkrPYkPc=" + } + } + }, + "once": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz", + "integrity": "sha1-WDsap3WWHUsROsF9nFC6753Xa9E=", + "requires": { + "wrappy": "1.0.2" + } + }, + "opener": { + "version": "1.4.3", + "resolved": "https://registry.npmjs.org/opener/-/opener-1.4.3.tgz", + "integrity": "sha1-XG2ixdflgx6P+jlklQ+NZnSskLg=" + }, + "osenv": { + "version": "0.1.4", + "resolved": "https://registry.npmjs.org/osenv/-/osenv-0.1.4.tgz", + "integrity": "sha1-Qv5tWVPfBsgGS+bxdsPQWqqjRkQ=", + "requires": { + "os-homedir": "1.0.2", + "os-tmpdir": "1.0.2" + }, + "dependencies": { + "os-homedir": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/os-homedir/-/os-homedir-1.0.2.tgz", + "integrity": "sha1-/7xJiDNuDoM94MFox+8VISGqf7M=" + }, + "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=" + } + } + }, + "pacote": { + "version": "6.0.1", + "resolved": "https://registry.npmjs.org/pacote/-/pacote-6.0.1.tgz", + "integrity": "sha512-BvGf8BnnkMcTqJk7MLimR8GWOsG/BJ+st4LS+Q82LoetVUQ1bqwoDw/WEjbUgfKdLIG/wKk9OWk9Zce8sNbPIw==", + "requires": { + "bluebird": "3.5.0", + "cacache": "9.2.9", + "glob": "7.1.2", + "lru-cache": "4.1.1", + "make-fetch-happen": "2.4.13", + "minimatch": "3.0.4", + "mississippi": "1.3.0", + "normalize-package-data": "2.4.0", + "npm-package-arg": "5.1.2", + "npm-packlist": "1.1.8", + "npm-pick-manifest": "1.0.4", + "osenv": "0.1.4", + "promise-inflight": "1.0.1", + "promise-retry": "1.1.1", + "protoduck": "4.0.0", + "safe-buffer": "5.1.1", + "semver": "5.4.1", + "ssri": "4.1.6", + "tar": "4.0.1", + "unique-filename": "1.1.0", + "which": "1.3.0" + }, + "dependencies": { + "make-fetch-happen": { + "version": "2.4.13", + "resolved": "https://registry.npmjs.org/make-fetch-happen/-/make-fetch-happen-2.4.13.tgz", + "integrity": "sha512-73CsTlMRSLdGr7VvOE8iYl/ejOSIxyfRYg7jZhepGGEqIlgdq6FLe2DEAI5bo813Jdg5fS/Ku62SRQ/UpT6NJA==", + "requires": { + "agentkeepalive": "3.3.0", + "cacache": "9.2.9", + "http-cache-semantics": "3.7.3", + "http-proxy-agent": "2.0.0", + "https-proxy-agent": "2.1.0", + "lru-cache": "4.1.1", + "mississippi": "1.3.0", + "node-fetch-npm": "2.0.2", + "promise-retry": "1.1.1", + "socks-proxy-agent": "3.0.0", + "ssri": "4.1.6" + }, + "dependencies": { + "agentkeepalive": { + "version": "3.3.0", + "resolved": "https://registry.npmjs.org/agentkeepalive/-/agentkeepalive-3.3.0.tgz", + "integrity": "sha512-9yhcpXti2ZQE7bxuCsjjWNIZoQOd9sZ1ZBovHG0YeCRohFv73SLvcm73PC9T3olM4GyozaQb+4MGdQpcD8m7NQ==", + "requires": { + "humanize-ms": "1.2.1" + }, + "dependencies": { + "humanize-ms": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/humanize-ms/-/humanize-ms-1.2.1.tgz", + "integrity": "sha1-xG4xWaKT9riW2ikxbYtv6Lt5u+0=", + "requires": { + "ms": "2.0.0" + }, + "dependencies": { + "ms": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz", + "integrity": "sha1-VgiurfwAvmwpAd9fmGF4jeDVl8g=" + } + } + } + } + }, + "http-cache-semantics": { + "version": "3.7.3", + "resolved": "https://registry.npmjs.org/http-cache-semantics/-/http-cache-semantics-3.7.3.tgz", + "integrity": "sha1-LzXFMuzSnx5UE7mvgztySjxvf3I=" + }, + "http-proxy-agent": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/http-proxy-agent/-/http-proxy-agent-2.0.0.tgz", + "integrity": "sha1-RkgqLwUjpNYIJVFwn0acs+SoX/Q=", + "requires": { + "agent-base": "4.1.1", + "debug": "2.6.8" + }, + "dependencies": { + "agent-base": { + "version": "4.1.1", + "resolved": "https://registry.npmjs.org/agent-base/-/agent-base-4.1.1.tgz", + "integrity": "sha512-yWGUUmCZD/33IRjG2It94PzixT8lX+47Uq8fjmd0cgQWITCMrJuXFaVIMnGDmDnZGGKAGdwTx8UGeU8lMR2urA==", + "requires": { + "es6-promisify": "5.0.0" + }, + "dependencies": { + "es6-promisify": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/es6-promisify/-/es6-promisify-5.0.0.tgz", + "integrity": "sha1-UQnWLz5W6pZ8S2NQWu8IKRyKUgM=", + "requires": { + "es6-promise": "4.1.1" + }, + "dependencies": { + "es6-promise": { + "version": "4.1.1", + "resolved": "https://registry.npmjs.org/es6-promise/-/es6-promise-4.1.1.tgz", + "integrity": "sha512-OaU1hHjgJf+b0NzsxCg7NdIYERD6Hy/PEmFLTjw+b65scuisG3Kt4QoTvJ66BBkPZ581gr0kpoVzKnxniM8nng==" + } + } + } + } + }, + "debug": { + "version": "2.6.8", + "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.8.tgz", + "integrity": "sha1-5zFTHKLt4n0YgiJCfaF4IdaP9Pw=", + "requires": { + "ms": "2.0.0" + }, + "dependencies": { + "ms": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz", + "integrity": "sha1-VgiurfwAvmwpAd9fmGF4jeDVl8g=" + } + } + } + } + }, + "https-proxy-agent": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/https-proxy-agent/-/https-proxy-agent-2.1.0.tgz", + "integrity": "sha512-/DTVSUCbRc6AiyOV4DBRvPDpKKCJh4qQJNaCgypX0T41quD9hp/PB5iUyx/60XobuMPQa9ce1jNV9UOUq6PnTg==", + "requires": { + "agent-base": "4.1.1", + "debug": "2.6.8" + }, + "dependencies": { + "agent-base": { + "version": "4.1.1", + "resolved": "https://registry.npmjs.org/agent-base/-/agent-base-4.1.1.tgz", + "integrity": "sha512-yWGUUmCZD/33IRjG2It94PzixT8lX+47Uq8fjmd0cgQWITCMrJuXFaVIMnGDmDnZGGKAGdwTx8UGeU8lMR2urA==", + "requires": { + "es6-promisify": "5.0.0" + }, + "dependencies": { + "es6-promisify": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/es6-promisify/-/es6-promisify-5.0.0.tgz", + "integrity": "sha1-UQnWLz5W6pZ8S2NQWu8IKRyKUgM=", + "requires": { + "es6-promise": "4.1.1" + }, + "dependencies": { + "es6-promise": { + "version": "4.1.1", + "resolved": "https://registry.npmjs.org/es6-promise/-/es6-promise-4.1.1.tgz", + "integrity": "sha512-OaU1hHjgJf+b0NzsxCg7NdIYERD6Hy/PEmFLTjw+b65scuisG3Kt4QoTvJ66BBkPZ581gr0kpoVzKnxniM8nng==" + } + } + } + } + }, + "debug": { + "version": "2.6.8", + "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.8.tgz", + "integrity": "sha1-5zFTHKLt4n0YgiJCfaF4IdaP9Pw=", + "requires": { + "ms": "2.0.0" + }, + "dependencies": { + "ms": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz", + "integrity": "sha1-VgiurfwAvmwpAd9fmGF4jeDVl8g=" + } + } + } + } + }, + "node-fetch-npm": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/node-fetch-npm/-/node-fetch-npm-2.0.2.tgz", + "integrity": "sha512-nJIxm1QmAj4v3nfCvEeCrYSoVwXyxLnaPBK5W1W5DGEJwjlKuC2VEUycGw5oxk+4zZahRrB84PUJJgEmhFTDFw==", + "requires": { + "encoding": "0.1.12", + "json-parse-better-errors": "1.0.1", + "safe-buffer": "5.1.1" + }, + "dependencies": { + "encoding": { + "version": "0.1.12", + "resolved": "https://registry.npmjs.org/encoding/-/encoding-0.1.12.tgz", + "integrity": "sha1-U4tm8+5izRq1HsMjgp0flIDHS+s=", + "requires": { + "iconv-lite": "0.4.18" + }, + "dependencies": { + "iconv-lite": { + "version": "0.4.18", + "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.4.18.tgz", + "integrity": "sha512-sr1ZQph3UwHTR0XftSbK85OvBbxe/abLGzEnPENCQwmHf7sck8Oyu4ob3LgBxWWxRoM+QszeUyl7jbqapu2TqA==" + } + } + }, + "json-parse-better-errors": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/json-parse-better-errors/-/json-parse-better-errors-1.0.1.tgz", + "integrity": "sha512-xyQpxeWWMKyJps9CuGJYeng6ssI5bpqS9ltQpdVQ90t4ql6NdnxFKh95JcRt2cun/DjMVNrdjniLPuMA69xmCw==" + } + } + }, + "socks-proxy-agent": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/socks-proxy-agent/-/socks-proxy-agent-3.0.0.tgz", + "integrity": "sha512-YJcT+SNNBgFoK/NpO20PChz0VnBOhkjG3X10BwlrYujd0NZlSsH1jbxSQ1S0njt3sOvzwQ2PvGqqUIvP4rNk/w==", + "requires": { + "agent-base": "4.1.1", + "socks": "1.1.10" + }, + "dependencies": { + "agent-base": { + "version": "4.1.1", + "resolved": "https://registry.npmjs.org/agent-base/-/agent-base-4.1.1.tgz", + "integrity": "sha512-yWGUUmCZD/33IRjG2It94PzixT8lX+47Uq8fjmd0cgQWITCMrJuXFaVIMnGDmDnZGGKAGdwTx8UGeU8lMR2urA==", + "requires": { + "es6-promisify": "5.0.0" + }, + "dependencies": { + "es6-promisify": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/es6-promisify/-/es6-promisify-5.0.0.tgz", + "integrity": "sha1-UQnWLz5W6pZ8S2NQWu8IKRyKUgM=", + "requires": { + "es6-promise": "4.1.1" + }, + "dependencies": { + "es6-promise": { + "version": "4.1.1", + "resolved": "https://registry.npmjs.org/es6-promise/-/es6-promise-4.1.1.tgz", + "integrity": "sha512-OaU1hHjgJf+b0NzsxCg7NdIYERD6Hy/PEmFLTjw+b65scuisG3Kt4QoTvJ66BBkPZ581gr0kpoVzKnxniM8nng==" + } + } + } + } + }, + "socks": { + "version": "1.1.10", + "resolved": "https://registry.npmjs.org/socks/-/socks-1.1.10.tgz", + "integrity": "sha1-W4t/x8jzQcU+0FbpKbe/Tei6e1o=", + "requires": { + "ip": "1.1.5", + "smart-buffer": "1.1.15" + }, + "dependencies": { + "ip": { + "version": "1.1.5", + "resolved": "https://registry.npmjs.org/ip/-/ip-1.1.5.tgz", + "integrity": "sha1-vd7XARQpCCjAoDnnLvJfWq7ENUo=" + }, + "smart-buffer": { + "version": "1.1.15", + "resolved": "https://registry.npmjs.org/smart-buffer/-/smart-buffer-1.1.15.tgz", + "integrity": "sha1-fxFLW2X6s+KjWqd1uxLw0cZJvxY=" + } + } + } + } + } + } + }, + "minimatch": { + "version": "3.0.4", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.0.4.tgz", + "integrity": "sha512-yJHVQEhyqPLUTgt9B83PXu6W3rx4MvvHvSUvToogpwoGDOUQ+yDrR0HRot+yOCdCO7u4hX3pWft6kWBBcqh0UA==", + "requires": { + "brace-expansion": "1.1.8" + }, + "dependencies": { + "brace-expansion": { + "version": "1.1.8", + "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.8.tgz", + "integrity": "sha1-wHshHHyVLsH479Uad+8NHTmQopI=", + "requires": { + "balanced-match": "1.0.0", + "concat-map": "0.0.1" + }, + "dependencies": { + "balanced-match": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.0.tgz", + "integrity": "sha1-ibTRmasr7kneFk6gK4nORi1xt2c=" + }, + "concat-map": { + "version": "0.0.1", + "resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz", + "integrity": "sha1-2Klr13/Wjfd5OnMDajug1UBdR3s=" + } + } + } + } + }, + "npm-pick-manifest": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/npm-pick-manifest/-/npm-pick-manifest-1.0.4.tgz", + "integrity": "sha512-MKxNdeyOZysPRTTbHtW0M5Fw38Jo/3ARsoGw5qjCfS+XGjvNB/Gb4qtAZUFmKPM2mVum+eX559eHvKywU856BQ==", + "requires": { + "npm-package-arg": "5.1.2", + "semver": "5.4.1" + } + }, + "promise-retry": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/promise-retry/-/promise-retry-1.1.1.tgz", + "integrity": "sha1-ZznpaOMFHaIM5kl/srUPaRHfPW0=", + "requires": { + "err-code": "1.1.2", + "retry": "0.10.1" + }, + "dependencies": { + "err-code": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/err-code/-/err-code-1.1.2.tgz", + "integrity": "sha1-BuARbTAo9q70gGhJ6w6mp0iuaWA=" + } + } + }, + "protoduck": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/protoduck/-/protoduck-4.0.0.tgz", + "integrity": "sha1-/kh02MeRM2bP2erRJFOiLNNlf44=", + "requires": { + "genfun": "4.0.1" + }, + "dependencies": { + "genfun": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/genfun/-/genfun-4.0.1.tgz", + "integrity": "sha1-7RAEHy5KfxsKOEZtF6XD4n3x38E=" + } + } + } + } + }, + "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=" + }, + "promise-inflight": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/promise-inflight/-/promise-inflight-1.0.1.tgz", + "integrity": "sha1-mEcocL8igTL8vdhoEputEsPAKeM=" + }, + "read": { + "version": "1.0.7", + "resolved": "https://registry.npmjs.org/read/-/read-1.0.7.tgz", + "integrity": "sha1-s9oZvQUkMal2cdRKQmNK33ELQMQ=", + "requires": { + "mute-stream": "0.0.7" + }, + "dependencies": { + "mute-stream": { + "version": "0.0.7", + "resolved": "https://registry.npmjs.org/mute-stream/-/mute-stream-0.0.7.tgz", + "integrity": "sha1-MHXOk7whuPq0PhvE2n6BFe0ee6s=" + } + } + }, + "read-cmd-shim": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/read-cmd-shim/-/read-cmd-shim-1.0.1.tgz", + "integrity": "sha1-LV0Vd4ajfAVdIgd8MsU/gynpHHs=", + "requires": { + "graceful-fs": "4.1.11" + } + }, + "read-installed": { + "version": "4.0.3", + "resolved": "https://registry.npmjs.org/read-installed/-/read-installed-4.0.3.tgz", + "integrity": "sha1-/5uLZ/GH0eTCm5/rMfayI6zRkGc=", + "requires": { + "debuglog": "1.0.1", + "graceful-fs": "4.1.11", + "read-package-json": "2.0.12", + "readdir-scoped-modules": "1.0.2", + "semver": "5.4.1", + "slide": "1.1.6", + "util-extend": "1.0.3" + }, + "dependencies": { + "util-extend": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/util-extend/-/util-extend-1.0.3.tgz", + "integrity": "sha1-p8IW0mdUUWljeztu3GypEZ4v+T8=" + } + } + }, + "read-package-json": { + "version": "2.0.12", + "resolved": "https://registry.npmjs.org/read-package-json/-/read-package-json-2.0.12.tgz", + "integrity": "sha512-m7/I0+tP6D34EVvSlzCtuVA4D/dHL6OpLcn2e4XVP5X57pCKGUy1JjRSBVKHWpB+vUU91sL85h84qX0MdXzBSw==", + "requires": { + "glob": "7.1.2", + "graceful-fs": "4.1.11", + "json-parse-better-errors": "1.0.1", + "normalize-package-data": "2.4.0", + "slash": "1.0.0" + }, + "dependencies": { + "json-parse-better-errors": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/json-parse-better-errors/-/json-parse-better-errors-1.0.1.tgz", + "integrity": "sha512-xyQpxeWWMKyJps9CuGJYeng6ssI5bpqS9ltQpdVQ90t4ql6NdnxFKh95JcRt2cun/DjMVNrdjniLPuMA69xmCw==" + }, + "slash": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/slash/-/slash-1.0.0.tgz", + "integrity": "sha1-xB8vbDn8FtHNF61LXYlhFK5HDVU=" + } + } + }, + "read-package-tree": { + "version": "5.1.6", + "resolved": "https://registry.npmjs.org/read-package-tree/-/read-package-tree-5.1.6.tgz", + "integrity": "sha512-FCX1aT3GWyY658wzDICef4p+n0dB+ENRct8E/Qyvppj6xVpOYerBHfUu7OP5Rt1/393Tdglguf5ju5DEX4wZNg==", + "requires": { + "debuglog": "1.0.1", + "dezalgo": "1.0.3", + "once": "1.4.0", + "read-package-json": "2.0.12", + "readdir-scoped-modules": "1.0.2" + } + }, + "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==", + "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" + }, + "dependencies": { + "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=" + }, + "isarray": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/isarray/-/isarray-1.0.0.tgz", + "integrity": "sha1-u5NdSFgsuhaMBoNJV6VKPgcSTxE=" + }, + "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=" + }, + "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==", + "requires": { + "safe-buffer": "5.1.1" + } + }, + "util-deprecate": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/util-deprecate/-/util-deprecate-1.0.2.tgz", + "integrity": "sha1-RQ1Nyfpw3nMnYvvS1KKJgUGaDM8=" + } + } + }, + "readdir-scoped-modules": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/readdir-scoped-modules/-/readdir-scoped-modules-1.0.2.tgz", + "integrity": "sha1-n6+jfShr5dksuuve4DDcm19AZ0c=", + "requires": { + "debuglog": "1.0.1", + "dezalgo": "1.0.3", + "graceful-fs": "4.1.11", + "once": "1.4.0" + } + }, + "request": { + "version": "2.81.0", + "resolved": "https://registry.npmjs.org/request/-/request-2.81.0.tgz", + "integrity": "sha1-xpKJRqDgbF+Nb4qTM0af/aRimKA=", + "requires": { + "aws-sign2": "0.6.0", + "aws4": "1.6.0", + "caseless": "0.12.0", + "combined-stream": "1.0.5", + "extend": "3.0.1", + "forever-agent": "0.6.1", + "form-data": "2.1.4", + "har-validator": "4.2.1", + "hawk": "3.1.3", + "http-signature": "1.1.1", + "is-typedarray": "1.0.0", + "isstream": "0.1.2", + "json-stringify-safe": "5.0.1", + "mime-types": "2.1.15", + "oauth-sign": "0.8.2", + "performance-now": "0.2.0", + "qs": "6.4.0", + "safe-buffer": "5.1.1", + "stringstream": "0.0.5", + "tough-cookie": "2.3.2", + "tunnel-agent": "0.6.0", + "uuid": "3.1.0" + }, + "dependencies": { + "aws-sign2": { + "version": "0.6.0", + "resolved": "https://registry.npmjs.org/aws-sign2/-/aws-sign2-0.6.0.tgz", + "integrity": "sha1-FDQt0428yU0OW4fXY81jYSwOeU8=" + }, + "aws4": { + "version": "1.6.0", + "resolved": "https://registry.npmjs.org/aws4/-/aws4-1.6.0.tgz", + "integrity": "sha1-g+9cqGCysy5KDe7e6MdxudtXRx4=" + }, + "caseless": { + "version": "0.12.0", + "resolved": "https://registry.npmjs.org/caseless/-/caseless-0.12.0.tgz", + "integrity": "sha1-G2gcIf+EAzyCZUMJBolCDRhxUdw=" + }, + "combined-stream": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/combined-stream/-/combined-stream-1.0.5.tgz", + "integrity": "sha1-k4NwpXtKUd6ix3wV1cX9+JUWQAk=", + "requires": { + "delayed-stream": "1.0.0" + }, + "dependencies": { + "delayed-stream": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/delayed-stream/-/delayed-stream-1.0.0.tgz", + "integrity": "sha1-3zrhmayt+31ECqrgsp4icrJOxhk=" + } + } + }, + "extend": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/extend/-/extend-3.0.1.tgz", + "integrity": "sha1-p1Xqe8Gt/MWjHOfnYtuq3F5jZEQ=" + }, + "forever-agent": { + "version": "0.6.1", + "resolved": "https://registry.npmjs.org/forever-agent/-/forever-agent-0.6.1.tgz", + "integrity": "sha1-+8cfDEGt6zf5bFd60e1C2P2sypE=" + }, + "form-data": { + "version": "2.1.4", + "resolved": "https://registry.npmjs.org/form-data/-/form-data-2.1.4.tgz", + "integrity": "sha1-M8GDrPGTJ27KqYFDpp6Uv+4XUNE=", + "requires": { + "asynckit": "0.4.0", + "combined-stream": "1.0.5", + "mime-types": "2.1.15" + }, + "dependencies": { + "asynckit": { + "version": "0.4.0", + "resolved": "https://registry.npmjs.org/asynckit/-/asynckit-0.4.0.tgz", + "integrity": "sha1-x57Zf380y48robyXkLzDZkdLS3k=" + } + } + }, + "har-validator": { + "version": "4.2.1", + "resolved": "https://registry.npmjs.org/har-validator/-/har-validator-4.2.1.tgz", + "integrity": "sha1-M0gdDxu/9gDdID11gSpqX7oALio=", + "requires": { + "ajv": "4.11.8", + "har-schema": "1.0.5" + }, + "dependencies": { + "ajv": { + "version": "4.11.8", + "resolved": "https://registry.npmjs.org/ajv/-/ajv-4.11.8.tgz", + "integrity": "sha1-gv+wKynmYq5TvcIK8VlHcGc5xTY=", + "requires": { + "co": "4.6.0", + "json-stable-stringify": "1.0.1" + }, + "dependencies": { + "co": { + "version": "4.6.0", + "resolved": "https://registry.npmjs.org/co/-/co-4.6.0.tgz", + "integrity": "sha1-bqa989hTrlTMuOR7+gvz+QMfsYQ=" + }, + "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=", + "requires": { + "jsonify": "0.0.0" + }, + "dependencies": { + "jsonify": { + "version": "0.0.0", + "resolved": "https://registry.npmjs.org/jsonify/-/jsonify-0.0.0.tgz", + "integrity": "sha1-LHS27kHZPKUbe1qu6PUDYx0lKnM=" + } + } + } + } + }, + "har-schema": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/har-schema/-/har-schema-1.0.5.tgz", + "integrity": "sha1-0mMTX0MwfALGAq/I/pWXDAFRNp4=" + } + } + }, + "hawk": { + "version": "3.1.3", + "resolved": "https://registry.npmjs.org/hawk/-/hawk-3.1.3.tgz", + "integrity": "sha1-B4REvXwWQLD+VA0sm3PVlnjo4cQ=", + "requires": { + "boom": "2.10.1", + "cryptiles": "2.0.5", + "hoek": "2.16.3", + "sntp": "1.0.9" + }, + "dependencies": { + "boom": { + "version": "2.10.1", + "resolved": "https://registry.npmjs.org/boom/-/boom-2.10.1.tgz", + "integrity": "sha1-OciRjO/1eZ+D+UkqhI9iWt0Mdm8=", + "requires": { + "hoek": "2.16.3" + } + }, + "cryptiles": { + "version": "2.0.5", + "resolved": "https://registry.npmjs.org/cryptiles/-/cryptiles-2.0.5.tgz", + "integrity": "sha1-O9/s3GCBR8HGcgL6KR59ylnqo7g=", + "requires": { + "boom": "2.10.1" + } + }, + "hoek": { + "version": "2.16.3", + "resolved": "https://registry.npmjs.org/hoek/-/hoek-2.16.3.tgz", + "integrity": "sha1-ILt0A9POo5jpHcRxCo/xuCdKJe0=" + }, + "sntp": { + "version": "1.0.9", + "resolved": "https://registry.npmjs.org/sntp/-/sntp-1.0.9.tgz", + "integrity": "sha1-ZUEYTMkK7qbG57NeJlkIJEPGYZg=", + "requires": { + "hoek": "2.16.3" + } + } + } + }, + "http-signature": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/http-signature/-/http-signature-1.1.1.tgz", + "integrity": "sha1-33LiZwZs0Kxn+3at+OE0qPvPkb8=", + "requires": { + "assert-plus": "0.2.0", + "jsprim": "1.4.0", + "sshpk": "1.13.1" + }, + "dependencies": { + "assert-plus": { + "version": "0.2.0", + "resolved": "https://registry.npmjs.org/assert-plus/-/assert-plus-0.2.0.tgz", + "integrity": "sha1-104bh+ev/A24qttwIfP+SBAasjQ=" + }, + "jsprim": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/jsprim/-/jsprim-1.4.0.tgz", + "integrity": "sha1-o7h+QCmNjDgFUtjMdiigu5WiKRg=", + "requires": { + "assert-plus": "1.0.0", + "extsprintf": "1.0.2", + "json-schema": "0.2.3", + "verror": "1.3.6" + }, + "dependencies": { + "assert-plus": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/assert-plus/-/assert-plus-1.0.0.tgz", + "integrity": "sha1-8S4PPF13sLHN2RRpQuTpbB5N1SU=" + }, + "extsprintf": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/extsprintf/-/extsprintf-1.0.2.tgz", + "integrity": "sha1-4QgOBljjALBilJkMxw4VAiNf1VA=" + }, + "json-schema": { + "version": "0.2.3", + "resolved": "https://registry.npmjs.org/json-schema/-/json-schema-0.2.3.tgz", + "integrity": "sha1-tIDIkuWaLwWVTOcnvT8qTogvnhM=" + }, + "verror": { + "version": "1.3.6", + "resolved": "https://registry.npmjs.org/verror/-/verror-1.3.6.tgz", + "integrity": "sha1-z/XfEpRtKX0rqu+qJoniW+AcAFw=", + "requires": { + "extsprintf": "1.0.2" + } + } + } + }, + "sshpk": { + "version": "1.13.1", + "resolved": "https://registry.npmjs.org/sshpk/-/sshpk-1.13.1.tgz", + "integrity": "sha1-US322mKHFEMW3EwY/hzx2UBzm+M=", + "requires": { + "asn1": "0.2.3", + "assert-plus": "1.0.0", + "bcrypt-pbkdf": "1.0.1", + "dashdash": "1.14.1", + "ecc-jsbn": "0.1.1", + "getpass": "0.1.7", + "jsbn": "0.1.1", + "tweetnacl": "0.14.5" + }, + "dependencies": { + "asn1": { + "version": "0.2.3", + "resolved": "https://registry.npmjs.org/asn1/-/asn1-0.2.3.tgz", + "integrity": "sha1-2sh4dxPJlmhJ/IGAd36+nB3fO4Y=" + }, + "assert-plus": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/assert-plus/-/assert-plus-1.0.0.tgz", + "integrity": "sha1-8S4PPF13sLHN2RRpQuTpbB5N1SU=" + }, + "bcrypt-pbkdf": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/bcrypt-pbkdf/-/bcrypt-pbkdf-1.0.1.tgz", + "integrity": "sha1-Y7xdy2EzG5K8Bf1SiVPDNGKgb40=", + "optional": true, + "requires": { + "tweetnacl": "0.14.5" + } + }, + "dashdash": { + "version": "1.14.1", + "resolved": "https://registry.npmjs.org/dashdash/-/dashdash-1.14.1.tgz", + "integrity": "sha1-hTz6D3y+L+1d4gMmuN1YEDX24vA=", + "requires": { + "assert-plus": "1.0.0" + } + }, + "ecc-jsbn": { + "version": "0.1.1", + "resolved": "https://registry.npmjs.org/ecc-jsbn/-/ecc-jsbn-0.1.1.tgz", + "integrity": "sha1-D8c6ntXw1Tw4GTOYUj735UN3dQU=", + "optional": true, + "requires": { + "jsbn": "0.1.1" + } + }, + "getpass": { + "version": "0.1.7", + "resolved": "https://registry.npmjs.org/getpass/-/getpass-0.1.7.tgz", + "integrity": "sha1-Xv+OPmhNVprkyysSgmBOi6YhSfo=", + "requires": { + "assert-plus": "1.0.0" + } + }, + "jsbn": { + "version": "0.1.1", + "resolved": "https://registry.npmjs.org/jsbn/-/jsbn-0.1.1.tgz", + "integrity": "sha1-peZUwuWi3rXyAdls77yoDA7y9RM=", + "optional": true + }, + "tweetnacl": { + "version": "0.14.5", + "resolved": "https://registry.npmjs.org/tweetnacl/-/tweetnacl-0.14.5.tgz", + "integrity": "sha1-WuaBd/GS1EViadEIr6k/+HQ/T2Q=", + "optional": true + } + } + } + } + }, + "is-typedarray": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/is-typedarray/-/is-typedarray-1.0.0.tgz", + "integrity": "sha1-5HnICFjfDBsR3dppQPlgEfzaSpo=" + }, + "isstream": { + "version": "0.1.2", + "resolved": "https://registry.npmjs.org/isstream/-/isstream-0.1.2.tgz", + "integrity": "sha1-R+Y/evVa+m+S4VAOaQ64uFKcCZo=" + }, + "json-stringify-safe": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/json-stringify-safe/-/json-stringify-safe-5.0.1.tgz", + "integrity": "sha1-Epai1Y/UXxmg9s4B1lcB4sc1tus=" + }, + "mime-types": { + "version": "2.1.15", + "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-2.1.15.tgz", + "integrity": "sha1-pOv1BkCUVpI3uM9wBGd20J/JKu0=", + "requires": { + "mime-db": "1.27.0" + }, + "dependencies": { + "mime-db": { + "version": "1.27.0", + "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.27.0.tgz", + "integrity": "sha1-gg9XIpa70g7CXtVeW13oaeVDbrE=" + } + } + }, + "oauth-sign": { + "version": "0.8.2", + "resolved": "https://registry.npmjs.org/oauth-sign/-/oauth-sign-0.8.2.tgz", + "integrity": "sha1-Rqarfwrq2N6unsBWV4C31O/rnUM=" + }, + "performance-now": { + "version": "0.2.0", + "resolved": "https://registry.npmjs.org/performance-now/-/performance-now-0.2.0.tgz", + "integrity": "sha1-M+8wxcd9TqIcWlOGnZG1bY8lVeU=" + }, + "qs": { + "version": "6.4.0", + "resolved": "https://registry.npmjs.org/qs/-/qs-6.4.0.tgz", + "integrity": "sha1-E+JtKK1rD/qpExLNO/cI7TUecjM=" + }, + "stringstream": { + "version": "0.0.5", + "resolved": "https://registry.npmjs.org/stringstream/-/stringstream-0.0.5.tgz", + "integrity": "sha1-TkhM1N5aC7vuGORjB3EKioFiGHg=" + }, + "tough-cookie": { + "version": "2.3.2", + "resolved": "https://registry.npmjs.org/tough-cookie/-/tough-cookie-2.3.2.tgz", + "integrity": "sha1-8IH3bkyFcg5sN6X6ztc3FQ2EByo=", + "requires": { + "punycode": "1.4.1" + }, + "dependencies": { + "punycode": { + "version": "1.4.1", + "resolved": "https://registry.npmjs.org/punycode/-/punycode-1.4.1.tgz", + "integrity": "sha1-wNWmOycYgArY4esPpSachN1BhF4=" + } + } + }, + "tunnel-agent": { + "version": "0.6.0", + "resolved": "https://registry.npmjs.org/tunnel-agent/-/tunnel-agent-0.6.0.tgz", + "integrity": "sha1-J6XeoGs2sEoKmWZ3SykIaPD8QP0=", + "requires": { + "safe-buffer": "5.1.1" + } + } + } + }, + "retry": { + "version": "0.10.1", + "resolved": "https://registry.npmjs.org/retry/-/retry-0.10.1.tgz", + "integrity": "sha1-52OI0heZLCUnUCQdPTlW/tmNj/Q=" + }, + "rimraf": { + "version": "2.6.1", + "resolved": "https://registry.npmjs.org/rimraf/-/rimraf-2.6.1.tgz", + "integrity": "sha1-wjOOxkPfeht/5cVPqG9XQopV8z0=", + "requires": { + "glob": "7.1.2" + } + }, + "safe-buffer": { + "version": "5.1.1", + "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.1.1.tgz", + "integrity": "sha512-kKvNJn6Mm93gAczWVJg7wH+wGYWNrDHdWvpUmHyEsgCtIwwo3bqPtV4tR5tuPaUhTOo/kvhVwd8XwwOllGYkbg==" + }, + "semver": { + "version": "5.4.1", + "resolved": "https://registry.npmjs.org/semver/-/semver-5.4.1.tgz", + "integrity": "sha512-WfG/X9+oATh81XtllIo/I8gOiY9EXRdv1cQdyykeXK17YcUW3EXUAi2To4pcH6nZtJPr7ZOpM5OMyWJZm+8Rsg==" + }, + "sha": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/sha/-/sha-2.0.1.tgz", + "integrity": "sha1-YDCCL70smCOUn49y7WQR7lzyWq4=", + "requires": { + "graceful-fs": "4.1.11", + "readable-stream": "2.3.3" + } + }, + "slide": { + "version": "1.1.6", + "resolved": "https://registry.npmjs.org/slide/-/slide-1.1.6.tgz", + "integrity": "sha1-VusCfWW00tzmyy4tMsTUr8nh1wc=" + }, + "sorted-object": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/sorted-object/-/sorted-object-2.0.1.tgz", + "integrity": "sha1-fWMfS9OnmKJK8d/8+/6DM3pd9fw=" + }, + "sorted-union-stream": { + "version": "2.1.3", + "resolved": "https://registry.npmjs.org/sorted-union-stream/-/sorted-union-stream-2.1.3.tgz", + "integrity": "sha1-x3lMfgd4gAUv9xqNSi27Sppjisc=", + "requires": { + "from2": "1.3.0", + "stream-iterate": "1.2.0" + }, + "dependencies": { + "from2": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/from2/-/from2-1.3.0.tgz", + "integrity": "sha1-iEE7qqX5pZfP3pIh2GmGzTwGHf0=", + "requires": { + "inherits": "2.0.3", + "readable-stream": "1.1.14" + }, + "dependencies": { + "readable-stream": { + "version": "1.1.14", + "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-1.1.14.tgz", + "integrity": "sha1-fPTFTvZI44EwhMY23SB54WbAgdk=", + "requires": { + "core-util-is": "1.0.2", + "inherits": "2.0.3", + "isarray": "0.0.1", + "string_decoder": "0.10.31" + }, + "dependencies": { + "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=" + }, + "isarray": { + "version": "0.0.1", + "resolved": "https://registry.npmjs.org/isarray/-/isarray-0.0.1.tgz", + "integrity": "sha1-ihis/Kmo9Bd+Cav8YDiTmwXR7t8=" + }, + "string_decoder": { + "version": "0.10.31", + "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-0.10.31.tgz", + "integrity": "sha1-YuIDvEF2bGwoyfyEMB2rHFMQ+pQ=" + } + } + } + } + }, + "stream-iterate": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/stream-iterate/-/stream-iterate-1.2.0.tgz", + "integrity": "sha1-K9fHcpbBcCpGSIuK1B95hl7s1OE=", + "requires": { + "readable-stream": "2.3.3", + "stream-shift": "1.0.0" + }, + "dependencies": { + "stream-shift": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/stream-shift/-/stream-shift-1.0.0.tgz", + "integrity": "sha1-1cdSgl5TZ+eG944Y5EXqIjoVWVI=" + } + } + } + } + }, + "ssri": { + "version": "4.1.6", + "resolved": "https://registry.npmjs.org/ssri/-/ssri-4.1.6.tgz", + "integrity": "sha512-WUbCdgSAMQjTFZRWvSPpauryvREEA+Krn19rx67UlJEJx/M192ZHxMmJXjZ4tkdFm+Sb0SXGlENeQVlA5wY7kA==", + "requires": { + "safe-buffer": "5.1.1" + } + }, + "strip-ansi": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-4.0.0.tgz", + "integrity": "sha1-qEeQIusaw2iocTibY1JixQXuNo8=", + "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=" + } + } + }, + "tar": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/tar/-/tar-4.0.1.tgz", + "integrity": "sha512-XBpU+/azPOMvE5m2Tn7Sl6U1ahpGfe77LkdrAlFilwrgHZsR+2iy0l8klQtfJNM+DACZO2Xrw10MTyQRB4du5A==", + "requires": { + "chownr": "1.0.1", + "minipass": "2.2.1", + "minizlib": "1.0.3", + "mkdirp": "0.5.1", + "yallist": "3.0.2" + }, + "dependencies": { + "minipass": { + "version": "2.2.1", + "resolved": "https://registry.npmjs.org/minipass/-/minipass-2.2.1.tgz", + "integrity": "sha512-u1aUllxPJUI07cOqzR7reGmQxmCqlH88uIIsf6XZFEWgw7gXKpJdR+5R9Y3KEDmWYkdIz9wXZs3C0jOPxejk/Q==", + "requires": { + "yallist": "3.0.2" + } + }, + "minizlib": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/minizlib/-/minizlib-1.0.3.tgz", + "integrity": "sha1-1cGr93vhVGGZUuJTM27Mq5sqMvU=", + "requires": { + "minipass": "2.2.1" + } + }, + "yallist": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/yallist/-/yallist-3.0.2.tgz", + "integrity": "sha1-hFK0u36Dx8GI2AQcGoN8dz1ti7k=" + } + } + }, + "text-table": { + "version": "0.2.0", + "resolved": "https://registry.npmjs.org/text-table/-/text-table-0.2.0.tgz", + "integrity": "sha1-f17oI66AUgfACvLfSoTsP8+lcLQ=" + }, + "uid-number": { + "version": "0.0.6", + "resolved": "https://registry.npmjs.org/uid-number/-/uid-number-0.0.6.tgz", + "integrity": "sha1-DqEOgDXo61uOREnwbaHHMGY7qoE=" + }, + "umask": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/umask/-/umask-1.1.0.tgz", + "integrity": "sha1-8pzr8B31F5ErtY/5xOUP3o4zMg0=" + }, + "unique-filename": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/unique-filename/-/unique-filename-1.1.0.tgz", + "integrity": "sha1-0F8v5AMlYIcfMOk8vnNe6iAVFPM=", + "requires": { + "unique-slug": "2.0.0" + }, + "dependencies": { + "unique-slug": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/unique-slug/-/unique-slug-2.0.0.tgz", + "integrity": "sha1-22Z258fMBimHj/GWCXx4hVrp9Ks=", + "requires": { + "imurmurhash": "0.1.4" + } + } + } + }, + "unpipe": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/unpipe/-/unpipe-1.0.0.tgz", + "integrity": "sha1-sr9O6FFKrmFltIF4KdIbLvSZBOw=" + }, + "update-notifier": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/update-notifier/-/update-notifier-2.2.0.tgz", + "integrity": "sha1-G1g3z5DAc22IYncytmHBOPht5y8=", + "requires": { + "boxen": "1.1.0", + "chalk": "1.1.3", + "configstore": "3.1.0", + "import-lazy": "2.1.0", + "is-npm": "1.0.0", + "latest-version": "3.1.0", + "semver-diff": "2.1.0", + "xdg-basedir": "3.0.0" + }, + "dependencies": { + "boxen": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/boxen/-/boxen-1.1.0.tgz", + "integrity": "sha1-sbad1SIwXoB6md7ud329blFnsQI=", + "requires": { + "ansi-align": "2.0.0", + "camelcase": "4.1.0", + "chalk": "1.1.3", + "cli-boxes": "1.0.0", + "string-width": "2.1.0", + "term-size": "0.1.1", + "widest-line": "1.0.0" + }, + "dependencies": { + "ansi-align": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/ansi-align/-/ansi-align-2.0.0.tgz", + "integrity": "sha1-w2rsy6VjuJzrVW82kPCx2eNUf38=", + "requires": { + "string-width": "2.1.0" + } + }, + "camelcase": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/camelcase/-/camelcase-4.1.0.tgz", + "integrity": "sha1-1UVjW+HjPFQmScaRc+Xeas+uNN0=" + }, + "cli-boxes": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/cli-boxes/-/cli-boxes-1.0.0.tgz", + "integrity": "sha1-T6kXw+WclKAEzWH47lCdplFocUM=" + }, + "string-width": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/string-width/-/string-width-2.1.0.tgz", + "integrity": "sha1-AwZkVh/BRslCPsfZeP4kV0N/5tA=", + "requires": { + "is-fullwidth-code-point": "2.0.0", + "strip-ansi": "4.0.0" + }, + "dependencies": { + "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=" + }, + "strip-ansi": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-4.0.0.tgz", + "integrity": "sha1-qEeQIusaw2iocTibY1JixQXuNo8=", + "requires": { + "ansi-regex": "3.0.0" + } + } + } + }, + "term-size": { + "version": "0.1.1", + "resolved": "https://registry.npmjs.org/term-size/-/term-size-0.1.1.tgz", + "integrity": "sha1-hzYLljlsq1dgljcUzaDQy+7K2co=", + "requires": { + "execa": "0.4.0" + }, + "dependencies": { + "execa": { + "version": "0.4.0", + "resolved": "https://registry.npmjs.org/execa/-/execa-0.4.0.tgz", + "integrity": "sha1-TrZGejaglfq7KXD/nV4/t7zm68M=", + "requires": { + "cross-spawn-async": "2.2.5", + "is-stream": "1.1.0", + "npm-run-path": "1.0.0", + "object-assign": "4.1.1", + "path-key": "1.0.0", + "strip-eof": "1.0.0" + }, + "dependencies": { + "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=", + "requires": { + "lru-cache": "4.1.1", + "which": "1.3.0" + } + }, + "is-stream": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/is-stream/-/is-stream-1.1.0.tgz", + "integrity": "sha1-EtSj3U5o4Lec6428hBc66A2RykQ=" + }, + "npm-run-path": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/npm-run-path/-/npm-run-path-1.0.0.tgz", + "integrity": "sha1-9cMr9ZX+ga6Sfa7FLoL4sACsPI8=", + "requires": { + "path-key": "1.0.0" + } + }, + "object-assign": { + "version": "4.1.1", + "resolved": "https://registry.npmjs.org/object-assign/-/object-assign-4.1.1.tgz", + "integrity": "sha1-IQmtx5ZYh8/AXLvUQsrIv7s2CGM=" + }, + "path-key": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/path-key/-/path-key-1.0.0.tgz", + "integrity": "sha1-XVPVeAGWRsDWiADbThRua9wqx68=" + }, + "strip-eof": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/strip-eof/-/strip-eof-1.0.0.tgz", + "integrity": "sha1-u0P/VZim6wXYm1n80SnJgzE2Br8=" + } + } + } + } + }, + "widest-line": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/widest-line/-/widest-line-1.0.0.tgz", + "integrity": "sha1-DAnIXCqUaD0Nfq+O4JfVZL8OEFw=", + "requires": { + "string-width": "1.0.2" + }, + "dependencies": { + "string-width": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/string-width/-/string-width-1.0.2.tgz", + "integrity": "sha1-EYvfW4zcUaKn5w0hHgfisLmxB9M=", + "requires": { + "code-point-at": "1.1.0", + "is-fullwidth-code-point": "1.0.0", + "strip-ansi": "3.0.1" + }, + "dependencies": { + "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=" + }, + "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=", + "requires": { + "number-is-nan": "1.0.1" + }, + "dependencies": { + "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=" + } + } + }, + "strip-ansi": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-3.0.1.tgz", + "integrity": "sha1-ajhfuIU9lS1f8F0Oiq+UJ43GPc8=", + "requires": { + "ansi-regex": "2.1.1" + }, + "dependencies": { + "ansi-regex": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-2.1.1.tgz", + "integrity": "sha1-w7M6te42DYbg5ijwRorn7yfWVN8=" + } + } + } + } + } + } + } + } + }, + "chalk": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-1.1.3.tgz", + "integrity": "sha1-qBFcVeSnAv5NFQq9OHKCKn4J/Jg=", + "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" + }, + "dependencies": { + "ansi-styles": { + "version": "2.2.1", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-2.2.1.tgz", + "integrity": "sha1-tDLdM1i2NM914eRmQ2gkBTPB3b4=" + }, + "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=" + }, + "has-ansi": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/has-ansi/-/has-ansi-2.0.0.tgz", + "integrity": "sha1-NPUEnOHs3ysGSa8+8k5F7TVBbZE=", + "requires": { + "ansi-regex": "2.1.1" + }, + "dependencies": { + "ansi-regex": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-2.1.1.tgz", + "integrity": "sha1-w7M6te42DYbg5ijwRorn7yfWVN8=" + } + } + }, + "strip-ansi": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-3.0.1.tgz", + "integrity": "sha1-ajhfuIU9lS1f8F0Oiq+UJ43GPc8=", + "requires": { + "ansi-regex": "2.1.1" + }, + "dependencies": { + "ansi-regex": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-2.1.1.tgz", + "integrity": "sha1-w7M6te42DYbg5ijwRorn7yfWVN8=" + } + } + }, + "supports-color": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-2.0.0.tgz", + "integrity": "sha1-U10EXOa2Nj+kARcIRimZXp3zJMc=" + } + } + }, + "configstore": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/configstore/-/configstore-3.1.0.tgz", + "integrity": "sha1-Rd+QcHPibfoc9LLVL1tgVF6qEdE=", + "requires": { + "dot-prop": "4.1.1", + "graceful-fs": "4.1.11", + "make-dir": "1.0.0", + "unique-string": "1.0.0", + "write-file-atomic": "2.3.0", + "xdg-basedir": "3.0.0" + }, + "dependencies": { + "dot-prop": { + "version": "4.1.1", + "resolved": "https://registry.npmjs.org/dot-prop/-/dot-prop-4.1.1.tgz", + "integrity": "sha1-qEk/C3te7sglJbXHWH+n3nyoWcE=", + "requires": { + "is-obj": "1.0.1" + }, + "dependencies": { + "is-obj": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/is-obj/-/is-obj-1.0.1.tgz", + "integrity": "sha1-PkcprB9f3gJc19g6iW2rn09n2w8=" + } + } + }, + "make-dir": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/make-dir/-/make-dir-1.0.0.tgz", + "integrity": "sha1-l6ARdR6R3YfPre9Ygy67BJNt6Xg=", + "requires": { + "pify": "2.3.0" + }, + "dependencies": { + "pify": { + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/pify/-/pify-2.3.0.tgz", + "integrity": "sha1-7RQaasBDqEnqWISY59yosVMw6Qw=" + } + } + }, + "unique-string": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/unique-string/-/unique-string-1.0.0.tgz", + "integrity": "sha1-nhBXzKhRq7kzmPizOuGHuZyuwRo=", + "requires": { + "crypto-random-string": "1.0.0" + }, + "dependencies": { + "crypto-random-string": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/crypto-random-string/-/crypto-random-string-1.0.0.tgz", + "integrity": "sha1-ojD2T1aDEOFJgAmUB5DsmVRbyn4=" + } + } + } + } + }, + "import-lazy": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/import-lazy/-/import-lazy-2.1.0.tgz", + "integrity": "sha1-BWmOPUXIjo1+nZLLBYTnfwlvPkM=" + }, + "is-npm": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/is-npm/-/is-npm-1.0.0.tgz", + "integrity": "sha1-8vtjpl5JBbQGyGBydloaTceTufQ=" + }, + "latest-version": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/latest-version/-/latest-version-3.1.0.tgz", + "integrity": "sha1-ogU4P+oyKzO1rjsYq+4NwvNW7hU=", + "requires": { + "package-json": "4.0.1" + }, + "dependencies": { + "package-json": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/package-json/-/package-json-4.0.1.tgz", + "integrity": "sha1-iGmgQBJTZhxMTKPabCEh7VVfXu0=", + "requires": { + "got": "6.7.1", + "registry-auth-token": "3.3.1", + "registry-url": "3.1.0", + "semver": "5.4.1" + }, + "dependencies": { + "got": { + "version": "6.7.1", + "resolved": "https://registry.npmjs.org/got/-/got-6.7.1.tgz", + "integrity": "sha1-JAzQV4WpoY5WHcG0S0HHY+8ejbA=", + "requires": { + "create-error-class": "3.0.2", + "duplexer3": "0.1.4", + "get-stream": "3.0.0", + "is-redirect": "1.0.0", + "is-retry-allowed": "1.1.0", + "is-stream": "1.1.0", + "lowercase-keys": "1.0.0", + "safe-buffer": "5.1.1", + "timed-out": "4.0.1", + "unzip-response": "2.0.1", + "url-parse-lax": "1.0.0" + }, + "dependencies": { + "create-error-class": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/create-error-class/-/create-error-class-3.0.2.tgz", + "integrity": "sha1-Br56vvlHo/FKMP1hBnHUAbyot7Y=", + "requires": { + "capture-stack-trace": "1.0.0" + }, + "dependencies": { + "capture-stack-trace": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/capture-stack-trace/-/capture-stack-trace-1.0.0.tgz", + "integrity": "sha1-Sm+gc5nCa7pH8LJJa00PtAjFVQ0=" + } + } + }, + "duplexer3": { + "version": "0.1.4", + "resolved": "https://registry.npmjs.org/duplexer3/-/duplexer3-0.1.4.tgz", + "integrity": "sha1-7gHdHKwO08vH/b6jfcCo8c4ALOI=" + }, + "get-stream": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/get-stream/-/get-stream-3.0.0.tgz", + "integrity": "sha1-jpQ9E1jcN1VQVOy+LtsFqhdO3hQ=" + }, + "is-redirect": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/is-redirect/-/is-redirect-1.0.0.tgz", + "integrity": "sha1-HQPd7VO9jbDzDCbk+V02/HyH3CQ=" + }, + "is-retry-allowed": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/is-retry-allowed/-/is-retry-allowed-1.1.0.tgz", + "integrity": "sha1-EaBgVotnM5REAz0BJaYaINVk+zQ=" + }, + "is-stream": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/is-stream/-/is-stream-1.1.0.tgz", + "integrity": "sha1-EtSj3U5o4Lec6428hBc66A2RykQ=" + }, + "lowercase-keys": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/lowercase-keys/-/lowercase-keys-1.0.0.tgz", + "integrity": "sha1-TjNms55/VFfjXxMkvfb4jQv8cwY=" + }, + "timed-out": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/timed-out/-/timed-out-4.0.1.tgz", + "integrity": "sha1-8y6srFoXW+ol1/q1Zas+2HQe9W8=" + }, + "unzip-response": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/unzip-response/-/unzip-response-2.0.1.tgz", + "integrity": "sha1-0vD3N9FrBhXnKmk17QQhRXLVb5c=" + }, + "url-parse-lax": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/url-parse-lax/-/url-parse-lax-1.0.0.tgz", + "integrity": "sha1-evjzA2Rem9eaJy56FKxovAYJ2nM=", + "requires": { + "prepend-http": "1.0.4" + }, + "dependencies": { + "prepend-http": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/prepend-http/-/prepend-http-1.0.4.tgz", + "integrity": "sha1-1PRWKwzjaW5BrFLQ4ALlemNdxtw=" + } + } + } + } + }, + "registry-auth-token": { + "version": "3.3.1", + "resolved": "https://registry.npmjs.org/registry-auth-token/-/registry-auth-token-3.3.1.tgz", + "integrity": "sha1-+w0yie4Nmtosu1KvXf5mywcNMAY=", + "requires": { + "rc": "1.2.1", + "safe-buffer": "5.1.1" + }, + "dependencies": { + "rc": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/rc/-/rc-1.2.1.tgz", + "integrity": "sha1-LgPo5C7kULjLPc5lvhv4l04d/ZU=", + "requires": { + "deep-extend": "0.4.2", + "ini": "1.3.4", + "minimist": "1.2.0", + "strip-json-comments": "2.0.1" + }, + "dependencies": { + "deep-extend": { + "version": "0.4.2", + "resolved": "https://registry.npmjs.org/deep-extend/-/deep-extend-0.4.2.tgz", + "integrity": "sha1-SLaZwn4zS/ifEIkr5DL25MfTSn8=" + }, + "minimist": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.0.tgz", + "integrity": "sha1-o1AIsg9BOD7sH7kU9M1d95omQoQ=" + }, + "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=" + } + } + } + } + }, + "registry-url": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/registry-url/-/registry-url-3.1.0.tgz", + "integrity": "sha1-PU74cPc93h138M+aOBQyRE4XSUI=", + "requires": { + "rc": "1.2.1" + }, + "dependencies": { + "rc": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/rc/-/rc-1.2.1.tgz", + "integrity": "sha1-LgPo5C7kULjLPc5lvhv4l04d/ZU=", + "requires": { + "deep-extend": "0.4.2", + "ini": "1.3.4", + "minimist": "1.2.0", + "strip-json-comments": "2.0.1" + }, + "dependencies": { + "deep-extend": { + "version": "0.4.2", + "resolved": "https://registry.npmjs.org/deep-extend/-/deep-extend-0.4.2.tgz", + "integrity": "sha1-SLaZwn4zS/ifEIkr5DL25MfTSn8=" + }, + "minimist": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.0.tgz", + "integrity": "sha1-o1AIsg9BOD7sH7kU9M1d95omQoQ=" + }, + "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=" + } + } + } + } + } + } + } + } + }, + "semver-diff": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/semver-diff/-/semver-diff-2.1.0.tgz", + "integrity": "sha1-S7uEN8jTfksM8aaP1ybsbWRdbTY=", + "requires": { + "semver": "5.4.1" + } + }, + "xdg-basedir": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/xdg-basedir/-/xdg-basedir-3.0.0.tgz", + "integrity": "sha1-SWsswQnsqNus/i3HK2A8F8WHCtQ=" + } + } + }, + "uuid": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/uuid/-/uuid-3.1.0.tgz", + "integrity": "sha512-DIWtzUkw04M4k3bf1IcpS2tngXEL26YUD2M0tMDUpnUrz2hgzUBlD55a4FjdLGPvfHxS6uluGWvaVEqgBcVa+g==" + }, + "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=", + "requires": { + "spdx-correct": "1.0.2", + "spdx-expression-parse": "1.0.4" + }, + "dependencies": { + "spdx-correct": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/spdx-correct/-/spdx-correct-1.0.2.tgz", + "integrity": "sha1-SzBz2TP/UfORLwOsVRlJikFQ20A=", + "requires": { + "spdx-license-ids": "1.2.2" + }, + "dependencies": { + "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=" + } + } + }, + "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=" + } + } + }, + "validate-npm-package-name": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/validate-npm-package-name/-/validate-npm-package-name-3.0.0.tgz", + "integrity": "sha1-X6kS2B630MdK/BQN5zF/DKffQ34=", + "requires": { + "builtins": "1.0.3" + }, + "dependencies": { + "builtins": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/builtins/-/builtins-1.0.3.tgz", + "integrity": "sha1-y5T662HIaWRR2zZTThQi+U8K7og=" + } + } + }, + "which": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/which/-/which-1.3.0.tgz", + "integrity": "sha512-xcJpopdamTuY5duC/KnTTNBraPK54YwpenP4lzxU8H91GudWpFv38u0CKjclE1Wi2EH2EDz5LRcHcKbCIzqGyg==", + "requires": { + "isexe": "2.0.0" + }, + "dependencies": { + "isexe": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz", + "integrity": "sha1-6PvzdNxVb/iUehDcsFctYz8s+hA=" + } + } + }, + "worker-farm": { + "version": "1.5.0", + "resolved": "https://registry.npmjs.org/worker-farm/-/worker-farm-1.5.0.tgz", + "integrity": "sha512-DHRiUggxtbruaTwnLDm2/BRDKZIoOYvrgYUj5Bam4fU6Gtvc0FaEyoswFPBjMXAweGW2H4BDNIpy//1yXXuaqQ==", + "requires": { + "errno": "0.1.4", + "xtend": "4.0.1" + }, + "dependencies": { + "errno": { + "version": "0.1.4", + "resolved": "https://registry.npmjs.org/errno/-/errno-0.1.4.tgz", + "integrity": "sha1-uJbiOp5ei6M4cfyZar02NfyaHH0=", + "requires": { + "prr": "0.0.0" + }, + "dependencies": { + "prr": { + "version": "0.0.0", + "resolved": "https://registry.npmjs.org/prr/-/prr-0.0.0.tgz", + "integrity": "sha1-GoS4WQgyVQFBGFPQCB7j+obikmo=" + } + } + }, + "xtend": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/xtend/-/xtend-4.0.1.tgz", + "integrity": "sha1-pcbVMr5lbiPbgg77lDofBJmNY68=" + } + } + }, + "wrappy": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz", + "integrity": "sha1-tSQ9jz7BqjXxNkYFvA0QNuMKtp8=" + }, + "write-file-atomic": { + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/write-file-atomic/-/write-file-atomic-2.3.0.tgz", + "integrity": "sha512-xuPeK4OdjWqtfi59ylvVL0Yn35SF3zgcAcv7rBPFHVaEapaDr4GdGgm3j7ckTwH9wHL7fGmgfAnb0+THrHb8tA==", + "requires": { + "graceful-fs": "4.1.11", + "imurmurhash": "0.1.4", + "signal-exit": "3.0.2" + }, + "dependencies": { + "signal-exit": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-3.0.2.tgz", + "integrity": "sha1-tf3AjxKH6hF4Yo5BXiUTK3NkbG0=" + } + } + } + } + }, + "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=" + }, + "object-component": { + "version": "0.0.3", + "resolved": "https://registry.npmjs.org/object-component/-/object-component-0.0.3.tgz", + "integrity": "sha1-8MaapQ78lbhmwYb0AKM3acsvEpE=" + }, + "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" + } + }, + "on-finished": { + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/on-finished/-/on-finished-2.3.0.tgz", + "integrity": "sha1-IPEzZIGwg811M3mSoWlxqi2QaUc=", + "requires": { + "ee-first": "1.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" + } + }, + "opener": { + "version": "1.4.3", + "resolved": "https://registry.npmjs.org/opener/-/opener-1.4.3.tgz", + "integrity": "sha1-XG2ixdflgx6P+jlklQ+NZnSskLg=" + }, + "optimist": { + "version": "0.6.1", + "resolved": "https://registry.npmjs.org/optimist/-/optimist-0.6.1.tgz", + "integrity": "sha1-2j6nRob6IaGaERwybpDrFaAZZoY=", + "requires": { + "minimist": "0.0.10", + "wordwrap": "0.0.3" + }, + "dependencies": { + "minimist": { + "version": "0.0.10", + "resolved": "https://registry.npmjs.org/minimist/-/minimist-0.0.10.tgz", + "integrity": "sha1-3j+YVD2/lggr5IrRoMfNqDYwHc8=" + } + } + }, + "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" + }, + "dependencies": { + "wordwrap": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/wordwrap/-/wordwrap-1.0.0.tgz", + "integrity": "sha1-J1hIEIkUVqQXHI0CJkQa3pDLyus=", + "dev": true + } + } + }, + "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-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 + }, + "osenv": { + "version": "0.1.4", + "resolved": "https://registry.npmjs.org/osenv/-/osenv-0.1.4.tgz", + "integrity": "sha1-Qv5tWVPfBsgGS+bxdsPQWqqjRkQ=", + "dev": true, + "requires": { + "os-homedir": "1.0.2", + "os-tmpdir": "1.0.2" + } + }, + "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-limit": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-1.1.0.tgz", + "integrity": "sha1-sH/y2aXYi+yAYDWJWiurZqJ5iLw=", + "dev": true + }, + "p-locate": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-2.0.0.tgz", + "integrity": "sha1-IKAQOyIqcMj9OcwuWAaA893l7EM=", + "dev": true, + "requires": { + "p-limit": "1.1.0" + } + }, + "package-json": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/package-json/-/package-json-1.2.0.tgz", + "integrity": "sha1-yOysCUInzfdqMWh07QXifMk5oOA=", + "dev": true, + "requires": { + "got": "3.3.1", + "registry-url": "3.1.0" + } + }, + "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.6", + "create-hash": "1.1.3", + "evp_bytestokey": "1.0.2", + "pbkdf2": "3.0.13" + } + }, + "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" + } + }, + "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" + } + }, + "parsejson": { + "version": "0.0.3", + "resolved": "https://registry.npmjs.org/parsejson/-/parsejson-0.0.3.tgz", + "integrity": "sha1-q343WfIJ7OmUN5c/fQ8fZK4OZKs=", + "requires": { + "better-assert": "1.0.2" + } + }, + "parseqs": { + "version": "0.0.5", + "resolved": "https://registry.npmjs.org/parseqs/-/parseqs-0.0.5.tgz", + "integrity": "sha1-1SCKNzjkZ2bikbouoXNoSSGouJ0=", + "requires": { + "better-assert": "1.0.2" + } + }, + "parseuri": { + "version": "0.0.5", + "resolved": "https://registry.npmjs.org/parseuri/-/parseuri-0.0.5.tgz", + "integrity": "sha1-gCBKUNTbt3m/3G6+J3jZDkvOMgo=", + "requires": { + "better-assert": "1.0.2" + } + }, + "parseurl": { + "version": "1.3.1", + "resolved": "https://registry.npmjs.org/parseurl/-/parseurl-1.3.1.tgz", + "integrity": "sha1-yKuMkiO6NIiKpkopeyiFO+wY2lY=" + }, + "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-exists": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-2.1.0.tgz", + "integrity": "sha1-D+tsZPD8UY2adU3V77YscCJ2H0s=", + "dev": true, + "requires": { + "pinkie-promise": "2.0.1" + } + }, + "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-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": "0.1.7", + "resolved": "https://registry.npmjs.org/path-to-regexp/-/path-to-regexp-0.1.7.tgz", + "integrity": "sha1-32BBeABfUi8V60SQ5yR6G/qmf4w=" + }, + "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.13", + "resolved": "https://registry.npmjs.org/pbkdf2/-/pbkdf2-3.0.13.tgz", + "integrity": "sha512-+dCHxDH+djNtjgWmvVC/my3SYBAKpKNqKSjLkp+GtWWYe4XPE+e/PSD2aCanlEZZnqPk2uekTKNC/ccbwd2X2Q==", + "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.8" + } + }, + "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" + } + }, + "pkg-dir": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/pkg-dir/-/pkg-dir-1.0.0.tgz", + "integrity": "sha1-ektQio1bstYp1EcFb/TpyTFM89Q=", + "dev": true, + "requires": { + "find-up": "1.1.2" + } + }, + "pluralize": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/pluralize/-/pluralize-4.0.0.tgz", + "integrity": "sha1-WbcIwcAZCi9pLxx2GMRGsFL9F2I=", + "dev": true + }, + "portfinder": { + "version": "1.0.13", + "resolved": "https://registry.npmjs.org/portfinder/-/portfinder-1.0.13.tgz", + "integrity": "sha1-uzLs2HwnEErm7kS1o8y/Drsa7ek=", + "requires": { + "async": "1.5.2", + "debug": "2.6.8", + "mkdirp": "0.5.1" + } + }, + "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 + }, + "prepend-http": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/prepend-http/-/prepend-http-1.0.4.tgz", + "integrity": "sha1-1PRWKwzjaW5BrFLQ4ALlemNdxtw=", + "dev": true + }, + "preserve": { + "version": "0.2.0", + "resolved": "https://registry.npmjs.org/preserve/-/preserve-0.2.0.tgz", + "integrity": "sha1-gV7R9uvGWSb4ZbMQwHE7yzMVzks=", + "dev": true + }, + "private": { + "version": "0.1.7", + "resolved": "https://registry.npmjs.org/private/-/private-0.1.7.tgz", + "integrity": "sha1-aM5eih7woju1cMwoU3tTMqumPvE=", + "dev": true + }, + "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 + }, + "proxy-addr": { + "version": "1.1.5", + "resolved": "https://registry.npmjs.org/proxy-addr/-/proxy-addr-1.1.5.tgz", + "integrity": "sha1-ccDuOxAt4/IC87ZPYI0XP8uhqRg=", + "requires": { + "forwarded": "0.1.0", + "ipaddr.js": "1.4.0" + } + }, + "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 + }, + "qs": { + "version": "2.3.3", + "resolved": "https://registry.npmjs.org/qs/-/qs-2.3.3.tgz", + "integrity": "sha1-6eha2+ddoLvkyOBHaghikPhjtAQ=" + }, + "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 + }, + "raf-js": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/raf-js/-/raf-js-1.0.1.tgz", + "integrity": "sha1-1tuZiSjdJeZvd1sqvRDW29QGBH8=", + "requires": { + "signal-js": "1.0.2" + } + }, + "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" + } + }, + "range-parser": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/range-parser/-/range-parser-1.2.0.tgz", + "integrity": "sha1-9JvmtIeJTdxA3MlKMi9hEJLgDV4=" + }, + "rc": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/rc/-/rc-1.2.1.tgz", + "integrity": "sha1-LgPo5C7kULjLPc5lvhv4l04d/ZU=", + "dev": true, + "requires": { + "deep-extend": "0.4.2", + "ini": "1.3.4", + "minimist": "1.2.0", + "strip-json-comments": "2.0.1" + } + }, + "read-all-stream": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/read-all-stream/-/read-all-stream-3.1.0.tgz", + "integrity": "sha1-NcPhd/IHjveJ7kv6+kNzB06u9Po=", + "dev": true, + "requires": { + "pinkie-promise": "2.0.1", + "readable-stream": "2.3.3" + } + }, + "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" + } + }, + "read-pkg-up": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/read-pkg-up/-/read-pkg-up-2.0.0.tgz", + "integrity": "sha1-a3KoBImE4MQeeVEP1en6mbO1Sb4=", + "dev": true, + "requires": { + "find-up": "2.1.0", + "read-pkg": "2.0.0" + }, + "dependencies": { + "find-up": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/find-up/-/find-up-2.1.0.tgz", + "integrity": "sha1-RdG35QbHF93UgndaK3eSCjwMV6c=", + "dev": true, + "requires": { + "locate-path": "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" + } + }, + "regenerate": { + "version": "1.3.2", + "resolved": "https://registry.npmjs.org/regenerate/-/regenerate-1.3.2.tgz", + "integrity": "sha1-0ZQcZ7rUN+G+dkM63Vs4X5WxkmA=", + "dev": true + }, + "regenerator-runtime": { + "version": "0.11.0", + "resolved": "https://registry.npmjs.org/regenerator-runtime/-/regenerator-runtime-0.11.0.tgz", + "integrity": "sha512-/aA0kLeRb5N9K0d4fw7ooEbI+xDe+DKD499EQqygGqeS8N3xto15p09uY2xj7ixP81sNPXvRLnAQIqdVStgb1A==", + "dev": true + }, + "regenerator-transform": { + "version": "0.10.1", + "resolved": "https://registry.npmjs.org/regenerator-transform/-/regenerator-transform-0.10.1.tgz", + "integrity": "sha512-PJepbvDbuK1xgIgnau7Y90cwaAmO/LCLMI2mPvaXq2heGMR3aWW5/BQvYrhJ8jgmQjXewXvBjzfqKcVOmhjZ6Q==", + "dev": true, + "requires": { + "babel-runtime": "6.26.0", + "babel-types": "6.26.0", + "private": "0.1.7" + } + }, + "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" + } + }, + "regexpu-core": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/regexpu-core/-/regexpu-core-2.0.0.tgz", + "integrity": "sha1-SdA4g3uNz4v6W5pCE5k45uoq4kA=", + "dev": true, + "requires": { + "regenerate": "1.3.2", + "regjsgen": "0.2.0", + "regjsparser": "0.1.5" + } + }, + "registry-url": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/registry-url/-/registry-url-3.1.0.tgz", + "integrity": "sha1-PU74cPc93h138M+aOBQyRE4XSUI=", + "dev": true, + "requires": { + "rc": "1.2.1" + } + }, + "regjsgen": { + "version": "0.2.0", + "resolved": "https://registry.npmjs.org/regjsgen/-/regjsgen-0.2.0.tgz", + "integrity": "sha1-bAFq3qxVT3WCP+N6wFuS1aTtsfc=", + "dev": true + }, + "regjsparser": { + "version": "0.1.5", + "resolved": "https://registry.npmjs.org/regjsparser/-/regjsparser-0.1.5.tgz", + "integrity": "sha1-fuj4Tcb6eS0/0K4ijSS9lJ6tIFw=", + "dev": true, + "requires": { + "jsesc": "0.5.0" + } + }, + "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-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" + } + }, + "requires-port": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/requires-port/-/requires-port-1.0.0.tgz", + "integrity": "sha1-kl0mAdOaxIXgkc8NpcbmlNw9yv8=" + }, + "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.1", + "resolved": "https://registry.npmjs.org/rimraf/-/rimraf-2.6.1.tgz", + "integrity": "sha1-wjOOxkPfeht/5cVPqG9XQopV8z0=", + "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" + } + }, + "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 + }, + "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 + }, + "semver-diff": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/semver-diff/-/semver-diff-2.1.0.tgz", + "integrity": "sha1-S7uEN8jTfksM8aaP1ybsbWRdbTY=", + "dev": true, + "requires": { + "semver": "5.4.1" + } + }, + "send": { + "version": "0.15.4", + "resolved": "https://registry.npmjs.org/send/-/send-0.15.4.tgz", + "integrity": "sha1-mF+qPihLAnPHkzZKNcZze9k5Bbk=", + "requires": { + "debug": "2.6.8", + "depd": "1.1.1", + "destroy": "1.0.4", + "encodeurl": "1.0.1", + "escape-html": "1.0.3", + "etag": "1.8.0", + "fresh": "0.5.0", + "http-errors": "1.6.2", + "mime": "1.3.4", + "ms": "2.0.0", + "on-finished": "2.3.0", + "range-parser": "1.2.0", + "statuses": "1.3.1" + }, + "dependencies": { + "mime": { + "version": "1.3.4", + "resolved": "https://registry.npmjs.org/mime/-/mime-1.3.4.tgz", + "integrity": "sha1-EV+eO2s9rylZmDyzjxSaLUDrXVM=" + } + } + }, + "serve-static": { + "version": "1.12.4", + "resolved": "https://registry.npmjs.org/serve-static/-/serve-static-1.12.4.tgz", + "integrity": "sha1-m2qpjutyU8Tu3Ewfb9vKYJkBqWE=", + "requires": { + "encodeurl": "1.0.1", + "escape-html": "1.0.3", + "parseurl": "1.3.1", + "send": "0.15.4" + } + }, + "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 + }, + "setprototypeof": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/setprototypeof/-/setprototypeof-1.0.3.tgz", + "integrity": "sha1-ZlZ+NwQ+608E2RvWWMDL77VbjgQ=" + }, + "sha.js": { + "version": "2.4.8", + "resolved": "https://registry.npmjs.org/sha.js/-/sha.js-2.4.8.tgz", + "integrity": "sha1-NwaMLEdra69ALRSknGf1l5IfY08=", + "dev": true, + "requires": { + "inherits": "2.0.3" + } + }, + "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.8" + } + }, + "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 + }, + "signal-js": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/signal-js/-/signal-js-1.0.2.tgz", + "integrity": "sha1-q+krDyFJenxxmDJ/M97kGxsl1Es=" + }, + "slash": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/slash/-/slash-1.0.0.tgz", + "integrity": "sha1-xB8vbDn8FtHNF61LXYlhFK5HDVU=", + "dev": true + }, + "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 + }, + "slide": { + "version": "1.1.6", + "resolved": "https://registry.npmjs.org/slide/-/slide-1.1.6.tgz", + "integrity": "sha1-VusCfWW00tzmyy4tMsTUr8nh1wc=", + "dev": true + }, + "socket.io": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/socket.io/-/socket.io-2.0.3.tgz", + "integrity": "sha1-Q1nwaiSTOua9CHeYr3jGgOrjReM=", + "requires": { + "debug": "2.6.8", + "engine.io": "3.1.1", + "object-assign": "4.1.1", + "socket.io-adapter": "1.1.1", + "socket.io-client": "2.0.3", + "socket.io-parser": "3.1.2" + } + }, + "socket.io-adapter": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/socket.io-adapter/-/socket.io-adapter-1.1.1.tgz", + "integrity": "sha1-KoBeihTWNyEk3ZFZrUUC+MsH8Gs=" + }, + "socket.io-client": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/socket.io-client/-/socket.io-client-2.0.3.tgz", + "integrity": "sha1-bK9K/5+FsZ/ZG2zhPWmttWT4hzs=", + "requires": { + "backo2": "1.0.2", + "base64-arraybuffer": "0.1.5", + "component-bind": "1.0.0", + "component-emitter": "1.2.1", + "debug": "2.6.8", + "engine.io-client": "3.1.1", + "has-cors": "1.1.0", + "indexof": "0.0.1", + "object-component": "0.0.3", + "parseqs": "0.0.5", + "parseuri": "0.0.5", + "socket.io-parser": "3.1.2", + "to-array": "0.1.4" + } + }, + "socket.io-parser": { + "version": "3.1.2", + "resolved": "https://registry.npmjs.org/socket.io-parser/-/socket.io-parser-3.1.2.tgz", + "integrity": "sha1-28IoIVH8T6675Aru3Ady66YZ9/I=", + "requires": { + "component-emitter": "1.2.1", + "debug": "2.6.8", + "has-binary2": "1.0.2", + "isarray": "2.0.1" + }, + "dependencies": { + "isarray": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/isarray/-/isarray-2.0.1.tgz", + "integrity": "sha1-o32U7ZzaLVmGXJ92/llu4fM4dB4=" + } + } + }, + "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-map-support": { + "version": "0.4.17", + "resolved": "https://registry.npmjs.org/source-map-support/-/source-map-support-0.4.17.tgz", + "integrity": "sha512-30c1Ch8FSjV0FwC253iftbbj0dU/OXoSg1LAEGZJUlGgjTNj6cu+DVqJWWIZJY5RXLWV4eFtR+4ouo0VIOYOTg==", + "dev": true, + "requires": { + "source-map": "0.5.7" + } + }, + "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" + } + }, + "sprintf-js": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/sprintf-js/-/sprintf-js-1.0.3.tgz", + "integrity": "sha1-BOaSb2YolTVPPdAVIDYzuFcpfiw=", + "dev": true + }, + "statuses": { + "version": "1.3.1", + "resolved": "https://registry.npmjs.org/statuses/-/statuses-1.3.1.tgz", + "integrity": "sha1-+vUbnrdKrvOzrPStX2Gr8ky3uT4=" + }, + "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-shift": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/stream-shift/-/stream-shift-1.0.0.tgz", + "integrity": "sha1-1cdSgl5TZ+eG944Y5EXqIjoVWVI=", + "dev": true + }, + "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" + } + }, + "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" + } + }, + "string-length": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/string-length/-/string-length-1.0.1.tgz", + "integrity": "sha1-VpcPscOFWOnnC3KL894mmsRa36w=", + "dev": true, + "requires": { + "strip-ansi": "3.0.1" + } + }, + "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" + }, + "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-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" + } + } + } + }, + "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" + } + }, + "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-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 + }, + "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.1", + "resolved": "https://registry.npmjs.org/table/-/table-4.0.1.tgz", + "integrity": "sha1-qBFsEz+sLGH0pCCrbN9cTWHw5DU=", + "dev": true, + "requires": { + "ajv": "4.11.8", + "ajv-keywords": "1.5.1", + "chalk": "1.1.3", + "lodash": "4.17.4", + "slice-ansi": "0.0.4", + "string-width": "2.1.1" + }, + "dependencies": { + "ajv": { + "version": "4.11.8", + "resolved": "https://registry.npmjs.org/ajv/-/ajv-4.11.8.tgz", + "integrity": "sha1-gv+wKynmYq5TvcIK8VlHcGc5xTY=", + "dev": true, + "requires": { + "co": "4.6.0", + "json-stable-stringify": "1.0.1" + } + }, + "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" + } + } + } + }, + "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 + }, + "three": { + "version": "0.87.1", + "resolved": "https://registry.npmjs.org/three/-/three-0.87.1.tgz", + "integrity": "sha1-Rmo07cRUNFnO2bnX0na2Uhb+K6g=" + }, + "three-mtl-loader": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/three-mtl-loader/-/three-mtl-loader-1.0.1.tgz", + "integrity": "sha1-wIlLxb2RfHTABDYel4scIiYAgos=", + "requires": { + "three": "0.79.0" + }, + "dependencies": { + "three": { + "version": "0.79.0", + "resolved": "https://registry.npmjs.org/three/-/three-0.79.0.tgz", + "integrity": "sha1-Ovlv2kf2i3qwk8KY36M1+kXaDPQ=" + } + } + }, + "three-obj-loader": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/three-obj-loader/-/three-obj-loader-1.1.2.tgz", + "integrity": "sha1-0sDjChrP2zROrAFDdVlEKaDiWlM=" + }, + "three-pointerlock": { + "version": "0.0.2", + "resolved": "https://registry.npmjs.org/three-pointerlock/-/three-pointerlock-0.0.2.tgz", + "integrity": "sha1-4HrgYwgRAsYTWhmNYccHiv5vTzc=" + }, + "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" + } + }, + "timed-out": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/timed-out/-/timed-out-2.0.0.tgz", + "integrity": "sha1-84sK6B03R9YoAB9B2vxlKs5nHAo=", + "dev": true + }, + "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.31", + "resolved": "https://registry.npmjs.org/tmp/-/tmp-0.0.31.tgz", + "integrity": "sha1-jzirlDjhcxXl29izZX6L+yd65Kc=", + "dev": true, + "requires": { + "os-tmpdir": "1.0.2" + } + }, + "to-array": { + "version": "0.1.4", + "resolved": "https://registry.npmjs.org/to-array/-/to-array-0.1.4.tgz", + "integrity": "sha1-F+bBH3PdTz10zaek/zI46a2b+JA=" + }, + "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 + }, + "to-fast-properties": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/to-fast-properties/-/to-fast-properties-1.0.3.tgz", + "integrity": "sha1-uDVx+k2MJbguIxsG46MFXeTKGkc=", + "dev": true + }, + "touch": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/touch/-/touch-1.0.0.tgz", + "integrity": "sha1-RJy+LbrlqMgDjjDXH6D/RklHxN4=", + "dev": true, + "requires": { + "nopt": "1.0.10" + } + }, + "trim-right": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/trim-right/-/trim-right-1.0.1.tgz", + "integrity": "sha1-yy4SAwZ+DI3h9hQJS5/kVwTqYAM=", + "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-is": { + "version": "1.6.15", + "resolved": "https://registry.npmjs.org/type-is/-/type-is-1.6.15.tgz", + "integrity": "sha1-yrEPtJCeRByChC6v4a1kbIGARBA=", + "requires": { + "media-typer": "0.3.0", + "mime-types": "2.1.17" + } + }, + "typedarray": { + "version": "0.0.6", + "resolved": "https://registry.npmjs.org/typedarray/-/typedarray-0.0.6.tgz", + "integrity": "sha1-hnrHTjhkGHsdPUfZlqeOxciDB3c=", + "dev": true + }, + "ultron": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/ultron/-/ultron-1.1.0.tgz", + "integrity": "sha1-sHoualQagV/Go0zNRTO67DB8qGQ=" + }, + "umd": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/umd/-/umd-3.0.1.tgz", + "integrity": "sha1-iuVW4RAR9jwllnCKiDclnwGz1g4=", + "dev": true + }, + "undefsafe": { + "version": "0.0.3", + "resolved": "https://registry.npmjs.org/undefsafe/-/undefsafe-0.0.3.tgz", + "integrity": "sha1-7Mo6A+VrmvFzhbqsgSrIO5lKli8=", + "dev": true + }, + "union": { + "version": "0.4.6", + "resolved": "https://registry.npmjs.org/union/-/union-0.4.6.tgz", + "integrity": "sha1-GY+9rrolTniLDvy2MLwR8kopWeA=", + "requires": { + "qs": "2.3.3" + } + }, + "unpipe": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/unpipe/-/unpipe-1.0.0.tgz", + "integrity": "sha1-sr9O6FFKrmFltIF4KdIbLvSZBOw=" + }, + "update-notifier": { + "version": "0.5.0", + "resolved": "https://registry.npmjs.org/update-notifier/-/update-notifier-0.5.0.tgz", + "integrity": "sha1-B7XcIGazYnqztPUwEw9+3doHpMw=", + "dev": true, + "requires": { + "chalk": "1.1.3", + "configstore": "1.4.0", + "is-npm": "1.0.0", + "latest-version": "1.0.1", + "repeating": "1.1.3", + "semver-diff": "2.1.0", + "string-length": "1.0.1" + }, + "dependencies": { + "repeating": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/repeating/-/repeating-1.1.3.tgz", + "integrity": "sha1-PUEUIYh3U3SU+X93+Xhfq4EPpKw=", + "dev": true, + "requires": { + "is-finite": "1.0.2" + } + } + } + }, + "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 + } + } + }, + "url-join": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/url-join/-/url-join-2.0.2.tgz", + "integrity": "sha1-wHJ1aWetJLi1nldBVRyqx49QuLc=" + }, + "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 + }, + "utils-merge": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/utils-merge/-/utils-merge-1.0.0.tgz", + "integrity": "sha1-ApT7kiu5N1FTVBxPcJYjHyh8ivg=" + }, + "uuid": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/uuid/-/uuid-2.0.3.tgz", + "integrity": "sha1-Z+LoY3lyFVMN/zGOW/nc6/1Hsho=", + "dev": true + }, + "uws": { + "version": "0.14.5", + "resolved": "https://registry.npmjs.org/uws/-/uws-0.14.5.tgz", + "integrity": "sha1-Z6rzPEaypYel9mZtAPdpEyjxSdw=", + "optional": 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" + } + }, + "vary": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/vary/-/vary-1.1.1.tgz", + "integrity": "sha1-Z1Neu2lMHVIldFeYRmUyP1h+jTc=" + }, + "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": "0.0.3", + "resolved": "https://registry.npmjs.org/wordwrap/-/wordwrap-0.0.3.tgz", + "integrity": "sha1-o9XabNXAvAAI03I0u68b7WMFkQc=" + }, + "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" + } + }, + "write-file-atomic": { + "version": "1.3.4", + "resolved": "https://registry.npmjs.org/write-file-atomic/-/write-file-atomic-1.3.4.tgz", + "integrity": "sha1-+Aek8LHZ6ROuekgRLmzDrxmRtF8=", + "dev": true, + "requires": { + "graceful-fs": "4.1.11", + "imurmurhash": "0.1.4", + "slide": "1.1.6" + } + }, + "ws": { + "version": "2.3.1", + "resolved": "https://registry.npmjs.org/ws/-/ws-2.3.1.tgz", + "integrity": "sha1-a5Sz5EfLajY/eF6vlK9jWejoHIA=", + "requires": { + "safe-buffer": "5.0.1", + "ultron": "1.1.0" + }, + "dependencies": { + "safe-buffer": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.0.1.tgz", + "integrity": "sha1-0mPKVGls2KMGtcplUekt5XkY++c=" + } + } + }, + "xdg-basedir": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/xdg-basedir/-/xdg-basedir-2.0.0.tgz", + "integrity": "sha1-7byQPMOF/ARSPZZqM1UEtVBNG9I=", + "dev": true, + "requires": { + "os-homedir": "1.0.2" + } + }, + "xmlhttprequest-ssl": { + "version": "1.5.3", + "resolved": "https://registry.npmjs.org/xmlhttprequest-ssl/-/xmlhttprequest-ssl-1.5.3.tgz", + "integrity": "sha1-GFqIjATspGw+QHDZn3tJ3jUomS0=" + }, + "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 + }, + "yeast": { + "version": "0.1.2", + "resolved": "https://registry.npmjs.org/yeast/-/yeast-0.1.2.tgz", + "integrity": "sha1-AI4G2AlDIMNy28L47XagymyKxBk=" + } + } +} diff --git a/src/init/init.js b/src/init/init.js index bc8ea6b..efe75e4 100644 --- a/src/init/init.js +++ b/src/init/init.js @@ -37,6 +37,7 @@ const bullet = () => { // create the scene const init = () => { + const timeStep = 1 / 60; // Cannon init @@ -44,7 +45,9 @@ const init = () => { world.gravity.set(0, -9.82, 0); world.broadphase = new CANNON.NaiveBroadphase(); world.solver.iterations = 10; - const shape = new CANNON.Box(new CANNON.Vec3(1, 1, 1)); + // shape is shape of geometry/wireframe + const shape = new CANNON.Box(new CANNON.Vec3(10, 10, 10)); + // body is it being effected by forces. const body = new CANNON.Body({ mass: 1, }); @@ -53,6 +56,16 @@ const init = () => { body.angularDamping = 0.5; body.position.set(0, 50, 0); world.addBody(body); + + var groundShape = new CANNON.Plane(); + var groundBody = new CANNON.Body({ mass: 0 }); + groundBody.addShape(groundShape); + groundBody.position.set(0,-14,0); + groundBody.quaternion.setFromAxisAngle(new CANNON.Vec3(1,0,0),-Math.PI/2); + world.add(groundBody); + + + // const camera = new THREE.PerspectiveCamera(75, -50, 1, 1000); const camera = new THREE.PerspectiveCamera(75, window.innerWidth / window.innerHeight, 1, 1000); // let's create the scene @@ -117,7 +130,7 @@ const init = () => { camera.updateProjectionMatrix(); renderer.setSize(window.innerWidth, window.innerHeight); } - console.log(scene.children[1]); + return { camera, scene, diff --git a/src/letsMove.js b/src/letsMove.js index c2a6880..79084e8 100644 --- a/src/letsMove.js +++ b/src/letsMove.js @@ -1,6 +1,6 @@ const THREE = require('three'); const pointLockers = require('./pointLockers'); - +const CANNON = require('cannon'); // const shoot = require('./shoot.js'); const { @@ -22,10 +22,13 @@ module.exports = function ( timeStep, ) { world.step(timeStep); + scene.children[1].position.copy(world.bodies[0].position); scene.children[1].quaternion.copy(world.bodies[0].quaternion); + + raycaster.ray.origin.copy(pointLockers().position); raycaster.ray.origin.y -= 10; const intersections = raycaster.intersectObjects(objects); @@ -53,37 +56,35 @@ module.exports = function ( new THREE.MeshBasicMaterial(), ); - // const shape = new CANNON.Sphere(new CANNON.Vec3(0.5)); - // const body = new CANNON.Body({ - // mass: 1, - // }); - // body.addShape(shape); - // body.angularVelocity.set(0, 50, 0); - // body.angularDamping = 0.5; - // body.position.set( - // raycaster.ray.origin.x, - // raycaster.ray.origin.y, - // raycaster.ray.origin.z, - // ); - // world.addBody(body); - - bullet.position.set( + const shape = new CANNON.Sphere(new CANNON.Vec3(0.5)); + const body = new CANNON.Body({ + mass: 1, + }); + body.addShape(shape); + body.position.set( raycaster.ray.origin.x, raycaster.ray.origin.y, raycaster.ray.origin.z, ); - bullet.velocity = new THREE.Vector3( - -Math.sin(pointerLockControls.getObject().rotation._y), - 0, -Math.cos(pointerLockControls.getObject().rotation._y), + world.addBody(body); + + bullet.position.copy(world.bodies[world.bodies.length-1].position); + bullet.quaternion.copy(world.bodies[world.bodies.length-1].quaternion); + + world.bodies[world.bodies.length-1] = new CANNON.Vec3( + -Math.sin(pointerLockControls.getObject().rotation._y), + 0, + -Math.cos(pointerLockControls.getObject().rotation._y), ); bullet.alive = true; setTimeout(() => { bullet.alive = false; scene.remove(bullet); - }, 1000); + world.remove(world.bodies[world.bodies.length-1]); + }, 3000); bullets.push(bullet); scene.add(bullet); } From 1513cadf836aeb70e9043068fd535328b16ef861 Mon Sep 17 00:00:00 2001 From: Yahia Date: Fri, 8 Sep 2017 14:08:10 +0100 Subject: [PATCH 6/9] can shoot and crate does not fall down --- src/init/init.js | 13 +------------ src/letsMove.js | 5 +++-- 2 files changed, 4 insertions(+), 14 deletions(-) diff --git a/src/init/init.js b/src/init/init.js index efe75e4..8a985fa 100644 --- a/src/init/init.js +++ b/src/init/init.js @@ -21,18 +21,7 @@ const blocker = require('../blocker'); // turnSpeed: Math.PI * 0.02 // }; -const bullet = () => { - const bullet = new THREE.Mesh( - new THREE.SphereGeometry(5, 8, 8), - new THREE.MeshBasicMaterial(), - ); - bullet.alive = true; - setTimeout(() => { - bullet.alive = false; - scene.remove(bullet); - }, 1000); - scene.add(bullet); -}; + // create the scene diff --git a/src/letsMove.js b/src/letsMove.js index 79084e8..6eac3de 100644 --- a/src/letsMove.js +++ b/src/letsMove.js @@ -46,7 +46,7 @@ module.exports = function ( bullets.splice(index, 1); continue; } - bullets[index].position.add(bullets[index].velocity); + // bullets[index].position.add(bullets[index].velocity); } if (movements.shooting) { @@ -73,12 +73,13 @@ module.exports = function ( bullet.quaternion.copy(world.bodies[world.bodies.length-1].quaternion); - world.bodies[world.bodies.length-1] = new CANNON.Vec3( + bullet.velocity = new CANNON.Vec3( -Math.sin(pointerLockControls.getObject().rotation._y), 0, -Math.cos(pointerLockControls.getObject().rotation._y), ); +console.log('thing',world.bodies[world.bodies.length-1] ); bullet.alive = true; setTimeout(() => { bullet.alive = false; From 3f5e5a553973360c60d35d4e456807cb2cd651ab Mon Sep 17 00:00:00 2001 From: RogeredBacon Date: Fri, 8 Sep 2017 14:13:32 +0000 Subject: [PATCH 7/9] Got the bullets to have physics, just no initial velocity yet #5 #4 --- src/init/init.js | 15 ++++++--------- src/letsMove.js | 17 +++++++++++------ 2 files changed, 17 insertions(+), 15 deletions(-) diff --git a/src/init/init.js b/src/init/init.js index 8a985fa..d3d974e 100644 --- a/src/init/init.js +++ b/src/init/init.js @@ -22,11 +22,9 @@ const blocker = require('../blocker'); // }; - // create the scene const init = () => { - const timeStep = 1 / 60; // Cannon init @@ -46,13 +44,12 @@ const init = () => { body.position.set(0, 50, 0); world.addBody(body); - var groundShape = new CANNON.Plane(); - var groundBody = new CANNON.Body({ mass: 0 }); - groundBody.addShape(groundShape); - groundBody.position.set(0,-14,0); - groundBody.quaternion.setFromAxisAngle(new CANNON.Vec3(1,0,0),-Math.PI/2); - world.add(groundBody); - + const groundShape = new CANNON.Plane(); + const groundBody = new CANNON.Body({ mass: 0 }); + groundBody.addShape(groundShape); + groundBody.position.set(0, -14, 0); + groundBody.quaternion.setFromAxisAngle(new CANNON.Vec3(1, 0, 0), -Math.PI / 2); + world.add(groundBody); // const camera = new THREE.PerspectiveCamera(75, -50, 1, 1000); diff --git a/src/letsMove.js b/src/letsMove.js index 6eac3de..36f7f42 100644 --- a/src/letsMove.js +++ b/src/letsMove.js @@ -8,6 +8,7 @@ const { } = require('./controls'); const bullets = []; +const cannonBullets = []; const velocity = new THREE.Vector3(); module.exports = function ( @@ -27,8 +28,6 @@ module.exports = function ( scene.children[1].quaternion.copy(world.bodies[0].quaternion); - - raycaster.ray.origin.copy(pointLockers().position); raycaster.ray.origin.y -= 10; const intersections = raycaster.intersectObjects(objects); @@ -43,10 +42,13 @@ module.exports = function ( continue; } if (bullets[index].alive == false) { + cannonBullets.splice(index, 1); bullets.splice(index, 1); continue; } // bullets[index].position.add(bullets[index].velocity); + bullets[index].position.copy(cannonBullets[index].position); + bullets[index].quaternion.copy(cannonBullets[index].quaternion); } if (movements.shooting) { @@ -69,8 +71,9 @@ module.exports = function ( world.addBody(body); - bullet.position.copy(world.bodies[world.bodies.length-1].position); - bullet.quaternion.copy(world.bodies[world.bodies.length-1].quaternion); + // bullet.position.copy(world.bodies[world.bodies.length - 1].position); + // bullet.quaternion.copy(world.bodies[world.bodies.length - 1].quaternion); + // console.log(cannonBullets[cannonBullets.length - 1]); bullet.velocity = new CANNON.Vec3( @@ -79,15 +82,17 @@ module.exports = function ( -Math.cos(pointerLockControls.getObject().rotation._y), ); -console.log('thing',world.bodies[world.bodies.length-1] ); + console.log('thing', world.bodies[world.bodies.length - 1]); bullet.alive = true; setTimeout(() => { bullet.alive = false; scene.remove(bullet); - world.remove(world.bodies[world.bodies.length-1]); + world.remove(world.bodies[world.bodies.length - 1]); }, 3000); + cannonBullets.push(world.bodies[world.bodies.length - 1]); bullets.push(bullet); scene.add(bullet); + cannonBullets[cannonBullets.length - 1].velocity = bullet.velocity; } if (movements.forward) { velocity.z -= 2000.0 * delta; } From 0d4d8ca0e6443b405fbe04c4290fa0bcbb33800a Mon Sep 17 00:00:00 2001 From: RogeredBacon Date: Fri, 8 Sep 2017 16:02:51 +0000 Subject: [PATCH 8/9] fixed up physics and bullets and planes and crates #4 #5 --- src/controls.js | 4 ++-- src/init/init.js | 4 +++- src/letsMove.js | 12 ++++++++---- 3 files changed, 13 insertions(+), 7 deletions(-) diff --git a/src/controls.js b/src/controls.js index c24fa9a..2a41b61 100644 --- a/src/controls.js +++ b/src/controls.js @@ -27,7 +27,7 @@ const init = () => { movements.canJump = false; } break; - case 17: + case 70: movements.shooting = true; break; } @@ -50,7 +50,7 @@ const init = () => { case 68: // d movements.right = false; break; - case 17: + case 70: movements.shooting = false; break; } diff --git a/src/init/init.js b/src/init/init.js index d3d974e..79cfe11 100644 --- a/src/init/init.js +++ b/src/init/init.js @@ -29,9 +29,10 @@ const init = () => { // Cannon init const world = new CANNON.World(); - world.gravity.set(0, -9.82, 0); + world.gravity.set(0, -20, 0); world.broadphase = new CANNON.NaiveBroadphase(); world.solver.iterations = 10; + world.solver = new CANNON.SplitSolver(new CANNON.GSSolver()); // shape is shape of geometry/wireframe const shape = new CANNON.Box(new CANNON.Vec3(10, 10, 10)); // body is it being effected by forces. @@ -45,6 +46,7 @@ const init = () => { world.addBody(body); const groundShape = new CANNON.Plane(); + groundShape.collisionResponse = true; const groundBody = new CANNON.Body({ mass: 0 }); groundBody.addShape(groundShape); groundBody.position.set(0, -14, 0); diff --git a/src/letsMove.js b/src/letsMove.js index 36f7f42..aebc076 100644 --- a/src/letsMove.js +++ b/src/letsMove.js @@ -44,6 +44,7 @@ module.exports = function ( if (bullets[index].alive == false) { cannonBullets.splice(index, 1); bullets.splice(index, 1); + world.remove(cannonBullets[index]); continue; } // bullets[index].position.add(bullets[index].velocity); @@ -54,14 +55,15 @@ module.exports = function ( if (movements.shooting) { // shoot.bullet(scene); const bullet = new THREE.Mesh( - new THREE.SphereGeometry(0.5, 8, 8), + new THREE.SphereGeometry(1.3, 8, 8), new THREE.MeshBasicMaterial(), ); - const shape = new CANNON.Sphere(new CANNON.Vec3(0.5)); + const shape = new CANNON.Sphere(new CANNON.Vec3(1.3)); const body = new CANNON.Body({ - mass: 1, + mass: 5, }); + body.linearDamping = 0; body.addShape(shape); body.position.set( raycaster.ray.origin.x, @@ -87,12 +89,14 @@ module.exports = function ( setTimeout(() => { bullet.alive = false; scene.remove(bullet); - world.remove(world.bodies[world.bodies.length - 1]); }, 3000); cannonBullets.push(world.bodies[world.bodies.length - 1]); bullets.push(bullet); scene.add(bullet); cannonBullets[cannonBullets.length - 1].velocity = bullet.velocity; + cannonBullets[cannonBullets.length - 1].velocity.x *= 150; + cannonBullets[cannonBullets.length - 1].velocity.y += 10; + cannonBullets[cannonBullets.length - 1].velocity.z *= 150; } if (movements.forward) { velocity.z -= 2000.0 * delta; } From 3ad3c6b446c5bb3f4ebe42aeabd7fec2813b1d9b Mon Sep 17 00:00:00 2001 From: Yahia Date: Mon, 11 Sep 2017 11:55:13 +0100 Subject: [PATCH 9/9] created a rotating health pack, and created a health HUD. Health pack uppdates life if picked up relates #8 #12 --- public/images/crate/healthpack.png | Bin 0 -> 637247 bytes src/animate.js | 2 ++ src/cubes.js | 20 ++++++++++++ src/init/getFloor.js | 17 ++++++++-- src/init/init.js | 50 +++++++++++++++++++++++------ src/letsMove.js | 39 ++++++++++++++++++++++ 6 files changed, 116 insertions(+), 12 deletions(-) create mode 100644 public/images/crate/healthpack.png diff --git a/public/images/crate/healthpack.png b/public/images/crate/healthpack.png new file mode 100644 index 0000000000000000000000000000000000000000..0eb962b697f2d0a33377da42dd08a2e4f76f8b22 GIT binary patch literal 637247 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

#vwg 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�u>(vr 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 ~g zdHLU-{KF8Cq9P&_V^ZGLT2$t;oO0Z_r1Q17uGgwU7M*&Np|ixv34$MR=6oUyiCb*G zS5uOLI@HOkX*#Kw7F|hS-DLr*OH_R@mUT(LO(%EnfHgO&LaE z+QNJM{t+*)zxUz4e@`3G-+mp!dmIasLLmF_>l!zobquF5b(a1Slcu{s`HUm;EuPbh znxNMeT3Izs=N^qCmR`sFA6-Bq9IRI5@2ygKP4Fh+5S+xD&w|xeO{pcw>a8gBP|*!+ zv`J(`psSO9BUlV4X+m8>yFS^_8tQ0B9c+60OT731-Vd)Vk(G zfD`^APFs3pGUr#{m@j3O%^@8R`+4YyxT z;r-X-lk_h?;6^ zDF(;$sy>Y&OuH(j?Gcxsh8r!Bl#$Lh~Gw>!vb}I zj+ez(*@A#zmnz;fSywXQ3v-7tzouC-CoxW%xaW3e^uDNqsa$~ulH;qcd$)6Eu)Mfe z%Cqc;V%!B*=1`#B9{Jai#!Vp2e7pL`Z}fy1VZ`=pF^_sLA&~TXE}e@w{%b z&u_A4Y+;zwSo&-G7Wcqa{SDVRfBz-^?#u8s{9n5MehGh?-{bgLQYU_m_eo-q#o~*m z%|cabd$)lW(i$~+=cMN%8VQWmY;RDgV+6x7HY(K^J?(=#aF4(Lttf18AqHyNjH2MZ zT@oi&+4dR+=oYcC9DG|LN>U5xc^{N6lBcn7Q5qa+??uOZEvx0?I$?2waiddVj;r^y zcN8TK+QrXi6~W2HfuYm!BuP_^5`uFAES4dkOo4$iC0pKba$37CvH#%v$#zmmZW)cm z-AXRtC)j@omp0LF{_>YUn~l>+1yo>zf#;MG-;`{R!$p%pQM=Yc^>hn=hfxFQ9AByD-(o=uGEA62@&2ke0J(Sle^#O-W{QrCC+}YZZ^NGQozAA%ltM?S4@=K zt(4+rSz+dBv3eJdtHf9`U1ogpGgv@PIjhE(@ld)N=Z+If~pPH2c2O#isVX8{&if5!Xf<|~r5j&673u*9^u;cnh;2G_dd5VsG7pp%ZtqqyHBRJHyG?`tH89q z-G=Yxv7|UBbR2~AqXm}pa+pVWe#+--ZId+aPFPDb-?@=_90Q`Q6uL;!-V#)9&39e+ zOU9Udo)lvYekfhE3Bn%hu12YxEp&1<3174`hv%QI6yS*`uwXN>J}73&^~&!UmdV{C ztUt{TL2crW-I+CnbZz61370>7jY*G~T$cencMClF!25uH^fjJO2bpc(xvq7F@%vhU z$#as?6Mo&rxD_aT9Sr5h7p^vz=38iJ8m^n1{)o?$4JnMdt1^a?*`E^+or z+v-ZeSSvXA_Lc%#tg`11e>3Kc$#K+!i#n^kH?!Js*LMm>UQN|h);s;oej~I=lVQ|a zNE5M$w|h#e`&4N39UPyyPLi%$*OUc1{Mh6522%O8eY2*Ty;l4#`R^=n;yK&AhafKT zP)pyPW12|~VZ+az*UuXA#D6JI)uD!%0|yxWGYSg|c(_jN+cGW$5{cyB&kYtg@k-}> z|2RJL$PvUxxUb+Ca)HJ}Co=-Tz9fNWm?-m(Jt_f(N=C8Z^F0y@-@-YRHBb`91jkI? zwsLRe+N9fuH4^t4@J?K({Qmv=mb--L&}ktv?{A()bO^^kzdn<@=iIw8p=b{{W)FS* zEnXW3+*uVaw1?m!lWU#IBKx?ZEsx|5-XsHI<{27^W3g0!jS$WoLM_o?g(*%7GUv{q zp+0HwNeL%y1#F9|OIY~5e_!pH=nX$$(^Y_F1J92QO1%^k$%#St(&~e(#gc#8HW?hP; zKL_7pD&5BKM*h?mtOm7XOp1QFx8e5w9{#ttIL>1bq<5!JotTAR34sx~Us@9S-UkHIHP*m7SA zYLJIo4$1+!TawbF-a|n5Do{!u)1#>6W=`aqd4pR#&pwU|X-u8gM|hbY;Sbk)xX1Bv ziO>Ao_iK2I_u|KEm*la*X$uMZr`8(+gWEn%?!u$3CN9TD=o8rK(j0=?!V+e6oMjVW z5>!YV$K>T6!oS{^@Tc?F@TW@?evyFxBpH5_6k`>p8T7e@wNLkF+7sr*!@5}bgo{!c z7HRxS+aq-SLgKF7hZzrEzajV&95*|!!7xv+6hHG=(f4juAHEiJ1+`O=f`)Y%x+z}z z98P2UtZ7dB%^f~+jlttBpvAo7E&~GdvevN_5PvV5?+a#LInev2y+4wmjdJZ|FTZcv zjC{=shKtVGhZbob;W8~Mn$*Xnwzv7Qp%~Jli?wDgsnf|UW7_q=j{+ypCs%&&1wc$iWW7&6fWE{Km7c1sji=Xe|#2qu*FXeaqao-eC$b7#-fL45Lx#LjmIeRtG12hzPg z>pA}N%P$!s3Kd$YnR-4Z-k*4Pa~3w@qRVPr&MwoLU`f_~CU>97-GBWnP3&-}3bV4( zvx!+#r35w@kdA_2e7aPt`rZh%mRN9w2b0n#7`!>vTK~1mG+zr>GHchxgx%UEQIpp% zVk>Y@94xT5F#Am_aTb?qhZOgN3G;rF$93`M?gde530utv$OncjsKc8PU=YC4$0+Nt zA$VUf?(}-=g?XBb&58X6nR9@|5>P`<-1&ZIp%HsOOx96h<3&0NR@~D$S6g&tyyTXs~LLMW0sf zr8$@bM+t~39*Wg}x9CP}$rnut^C_PdHOBk46tE)}*_a;7)1cHBFRHoS z^!N~g!Ru-jInec0k2f#T?h7PY#6jO*2BIAxukzU1ZUGWB@<$XNWT-&)4lq?On6e(PFCUlqeA%b2rLLbxhqT~j^)X->?OBxE z>d=HLADla0&jNk5s<`h0IvgY;0R*(ncbhnPPaU07sHSPy`eoJA=5d?RIAkpWUSWby zH`P5qKQ|IG|lo^t`t$X1Eb{OFe$(?}uAvI0{QQ|s-qwZru6HP2f5JfR`syphzi#&Mz~bnY@tjS~(ZNFumo zpDmp@Hc31@0h1NMT1^DTCvv{S1Dre-MVuQ8XYhtmtIo_07Ub0i7gx1ILRB+UttHP4 z3t`9%SJV6k#S1>*lKfuYP9F%I<6(lVvp_iS}q?p&NXg6b`4Dw9GA_dh*^m z{9$Utf7_byRTR1AUW40nV`H;R{FMLW@@x1%`=8;9@LB|c7=!(FzK6#x9(&#kC8Aa- z8AIx5?Q^iD;HH+u*A!4OUjdt`NwI@hG!j2i@5eM3-B6e)kGYUy0yoPp+Cg^Ld`v2dS_wXuQtNx^_i9tA8a^Fv4ydKAfbb_0Z_~6Qw zY%LkO74z?4W=^&lzQC6QYv&=x9B_0_iu*%}WViXkLdYDy;(WRUTMQ1~)r<+fAcdMZ z7~|)4agN8JaGX^wGZ`)SyA90QL@6E?fHvzPFlAUZIv2I#4I@PkTtj<3XagMd@@wvW z3})9QykFBgev0Gw>un1!Kki|;-{Kq1f=_ahJs7 z63*Z}bQb(Cgsvt#9a~>tUoVHG)+bx6x{bZTn~~R)RBMXbg{Y1oM_h5lCxx&=;vy%< zD-iea$sHp}YRD;8#;(Ds@h3QQ%q`?%9e1X@{R=0*9%9O{?8Dkm@Apd*D_>od9g%`b+YJxlohGqBEDFb;`khJ$g3j`7qSNcyfB!$~mN zmnX18Omt4VYLL>}br!Hk;JoCYW8dS|jfIC<< zs7Z|rSc4%x>(cmy&Od+t=A zn82MnuW;FPqY0>B+?q1m-LAO}g+HW!4*I-8;@1g`PDKL<#x;(o@DdL)u5mMt-@|Ih zFw<+T7>Zf&a^#GHXQ)Avh_`eJ?w2;L^qlTbo-cQn{r%@o>OvLtLa}vOv#?505e`iW zOEe!nJO=zJkN4!#8ON$wcb~c@na39MH+OIB?-sn|u@@ZgC?*wpO{QY0*Pyos>U#_p6kP!P%RYKyF7jL*vG1mVg_A!afz zs9GYTQyXQ@636hS}qFXGbA}-0j}Rd=6D1P7ZY(^H6HXc6b-Br*kGMe zKCEF-i=%*afvTfd)bw0Io-^2gJXHn>FMHY5IR2n*aACpw0MBGsrQ zMaSKq)BL1+k7odr_nE|)KskUe1Qfe#UW$MH`}cH>P3bY2ivZhP#3R4eeEIzPOzsW? z^_WN;Z4#b&}E-EUN1Knk^s} zWt4W($EAUAACuf}D+-{xZrVBsE0mU07HdY-fX&schLW|!cGw%iMMU7t$L8cP-QSp; ziRDlHNU=9K-{$a7aZUW+V-oh?$1h=w>z8!w;|+}^_&?#h`>9Mv?( zG-;H^ZP!){sk!6c_LkgT4|9q;N6hc_9hzEa+3&R;mh2OO-Rfhh7Al_=fbqG2y?VH7 z4pfQL{)|^%3;4b8S1lRjebpBMxOh_QhO$+Xj|sd|Iv4Uie~!mptwRPYC@5X>aab^j zKhGn#YQ-J)&*i<&3#Rb(xH=$U( zed01dle>?SyJx|B4g2di&#gi<_mwD2g0x7K%4w*)d9ze+LR*7NFpk~_{jA(r;}CiE zwr9{LZ#?eRp1_AX_&0^%OnsLsak_KlXnrpT(nUf+=g3mVwd=?Vi$v_@#f=w5uDl_T zm&)Ta*d79i+NOnj#VVp|O0BS)-FW*np7KV)Sa;q$KdPQ;w=0xSmaPB4W_6beas{c}}A1ph|;)Vl|ma?tRp_!U*YYf9-fy3=1y2utM2A&l2EGTlhj= z=gB@FP#T-FCR%WQ`5I2bx!ZIA?PE}b{3Z#d_@qL4S&cpCv94BWJgrXDL}f!3p&v`+ zHK3C5<3u>@B+Fz*P8dm{tBm6si$Je4SRs!6u*7Gvz#_o(JBhMv2psjs1e3{E#gud} z@_1JL$0B8+0a_12+t%s0@BrL4b((O1s#(i*S&XMi!CR zm%Fm6l)rTDL|HWp4G65wKEJV!YhlMDutFJ6@_S1RGYrs@yZro2MKzDr0}u!FFcY`thaSZ$d671Xt*2kGWI6O6bjX54q81wmiMo` z{tSCZiRU_Z5V+ff_algHM=5Nzg++=KA6{Nx!XID%5H3rc$MZG3EpIBQGHkPU>Xxh7 zt88hWUryo&d)hfuCLGaQ5%qpg#~8C-2w2B!$PKUDj81GWCfRfFf+c>P!~Nv_ zA5;$%toS`%bb}R^{j=bLr7wW;UQ{dO;yB!;s&QJ85HTDT?}JRgPZ)g{TrG>xVLqR8 zoP#mo3)GxMa>0Q+QyfFo)JZW0QJhBN1Nb5%MUcGLgwq&C?1lOmk;RIf?1}4(^B$RX zyS?Y*$UTyH3B?iZyc@5Q?X|!&Pt>AIjwdmu7~vM0J((+2jX!gj&*bidq)r$A&>n)f zG-0u(JD+nm3jt%%&01EgB9($448_Ez}Fh#uvOu| z@oogMpX)6d3in(5#Vx5oPVs&W$tYKZXEgBL5>!uH0jHS!%Y2GIzYM3)$3*2ObE)Zd zGk}dlI$x{OB8iW|qy){kCKPI~UM|{qcKKfN9AhXoCo~;#CG_`GGUCm_M2qup5-Mh7lLC#6OCGC@q|1)4^$qx_5 z`Q>U!U~5UC1nu#e$g4y!bGc8-M^iXneAa{92f=C1*44>|6rppX+j?o6_Xi}CSV4j?;t9y%@{<`jHRb?rXI^NHs$znj?9U7^?_ zs4_YU{rO>#VS}Z6PcO_%F9O9-IZf2o)cwHT$7;s#ZN*sj9WhNFt_IhP$@ptrtG>n8 z|M6%1`_K3A>%9wKZr3=X;v8-t+QEx=SM5HAdwSkWygdMRK#9LE!xx362`XWSzwdO2 zWSf%q=TjU9ZPTd`6p}mNwan{=J!fz4Bk#d}>65u!a04fnI{#egLy_`yIp^OOoLr(q zaMujqI41~%FbtN@g*5|eg?Mj8;P-J9SNXlzm%Vv9CrE7J#K;wY4Y%tM&yd7P zu>c)!Ili1X;<(!Ul)Vk{r@ZgW`AhiopZ^@jlc~Edj}nOxoa$UA5f>5VJoVpyh#8m;GYNIdj#6gI=HCjGR(k3I%|r*@V^4SM)zTLm32QJ2Ji?uVWBSP;$U4*ZDc6f;W@$qA=bJA%D%QaNJ$+u zb(s%C-=x3xZQ|Sk1tKu$nDC&`u{dNw?vCP_h@gl(CmAOOsZ}csN$TX>;5kL(5xhJ3 zp6L14)MQ0aqg=ldBpZoh5UUMMjQ6fy(IM(>42eq4CWX>2uX_k6MQw5oWq~0F$Fx7y z`0*@=<)Lf(xnV1caVW6Kx+$Lz|2yw*#~fPShu4J=B2q-@X+5!oe@*JhA{V4ddZET0 zstVjt806%G3yo4#@bW>J(0N~H|*m7IK+h$~mVdc>8(T0(rgUW;=_l?Y#4nW}Ny5HxeO zl@lWGQ^pG*->+u@f`{vIR|~SgH7=wN{JjzGGXWfi+SbNoEx`6;m0#!8t~^AR6JEb@ zvcOGEaa1e2(<2LfusF*RO0!ivo1NIx-BU$QQ~@Cr68Z$aQ}R_zV!Bxx7V+NoX+AAu zOgzR`1L5APd17upuO_wn$ETz!9U3TnaBZn}nS#u>)`TJQ+ze0@>(87iTcoUk~Hk27*1 z@^L>TNc<zNo& z2@fvEfAi^Q_nF-N-Y>?KdtnV;tlG{`q%z=Q$d^}fLK|CyqYf~Lkh?%KIr^c_b$h11 zd4N!m00x3EzJ_O$2*2}E_Z~mbiJ^y7FeHrwV?K9Qnc^TCun^`9aOKfg4y$B%TkM!e zQLC)`Y922>V)FjXn4XhU#k>iJQj%m^vle^~B zX;PSApRT*vbZT6_&&lne^r_F6OyGU-0ORu+N5bFB!op$;1?Mu)nXTNwcQa*suFm(c z6+RD=KkEL5B?ZpiFdkr;$xF*B|EIC+OeF(B6{1i=RE? z!K?*q`PreXgkn?E?vO(5Y%aMt*5-TO?AgVE^%sFBHZ7u{9a9V-yZ^^V=WoA=H2t6haD7#?Kqw@S!?UZEK{WH~{n;k_F zytD6JAoFu3xwt=-^GW`ALO&>i*p`xKn~NQFId!BeN79T9X?@qkpxfbCUaDW`TZO;q zJ32LQ*qmI9Ly^RA(MHxzpS*g(j}3(?9Y`f#JS&ohB$m=Oao(8EW?0Md+JvpzdD=GY z7glU&lXqZaj|EmNOh@1Z&m%Yd@jYkF7j*gkUebTbM(uOHU*2ZNeI-@OC!gx7McDTr%Mr{S=t^0S5258%$+QOABQ_dtH1I(6x_FR!U{E^3({b(cQ{ zRX&ru|8nx@E9%cWB+rsBELi)1-;<6637Vh6i)#4c17X?0HT}fq$`&s`3~%%ut{TM8 zL;LV|5VC6~sthftEspYYsr;~53N|P&_Tp8&@Vm3|8yU`6>p=PHCUe^SW>au(Ecs_x z1$W_CYPn`cip??0_7ij^nUF7qNR6-l)y|14uQd@L&q=8L&Z}y9$O(Hu)vhgfYsX7A z)!w;IB83jPS{i@twjMTDeJ1hxw@x;QAxtr7xpfi%O{yTcD(q|1p5Cxh2U3Hh_#6br z6@Mo{ClweNVnP>_A^Cn-g8BXZP2cmrna5x&2H{;eSx4vlIv?Q5JI`f2a7O+3_MN>P z5ST#7#flgEz;*L$Xbwd6Dnw>`0_EX(VFA7#1D(>xqg-3Mc8B4~`AYI;34ucP00m|~ z6$Si(p0yu0wSrWCJ{N)~DtKc7jb3Bd6p5i)N2Ih&1O9Qe_jWj+wMaxRkBt}YV{m_` zZkAjd`@hK;-p1$beC4QZPr9ZST%Z5A-xIQW$eqjeu47q>AUYQcK^#$d9nJb7j^mj5 zCqKJZ3mQ_m>A?wX!8J|yV{NTtyS3%D+d0&%Zfb_oDyTxqnIG$H(p=*NZR>K_4;c-y z&dZ1UY!0e5(I3>Jq+9mxd4e^M;pE`yFHI^czCWf)LR5BMYhn=WIm(?0--!V-!;kG; ztN~1}-!vZ=FZ1`f*1flLc(S)Nj(rU*)%#F z)RUj>yz-2cTSZV$>tNWZSL$Y31$Rf8U-!)4k*$3oegeL^ zS4qF!_E-q_0fl9T|MGEx&XTcrpVIkE^IGMshizA{|H!iF^XoIYD>ge2V(VUGsOBBv zHnl z7-%=rHcxr}0=!)MBFR9ZWZA6C)s~%!H6%4jUz|wZXpP0Q+rbtC^M>Kg&&Ed$Mw2^> z>sEzRH(Mw+vC}zmRr)+ejdzPtCN6q&dLM{y@ zT&xz#3YwJM1()1~wJSQ0!6&tk$5S*#I*-$SJlI4~lGlCtvfp1Qc_O*i#LDaj;`I%p z5Q+{}yK_Vf!IdT@w##Ng{Cz$Kcd`zlt&{syv$f97=%I2rRDJx-WCf3H@o#+XBVisawNejYZ= z9YG#n5b{GZ=e+@;Qag->FbGplMzyfgg^zimpZVQqa#ssbl40+&#K54APt0L!{wlmk zV$?Cj%69^5_6ap^NUdXl*Vfc1nZpLJAC>`TvMsC&d^;YC7RwjcI#Uk{ez@Jwm~vjo zJ*SYB1F=DPD5J;6^Er4ESHHP)*Uj_Cd~#L`-dK2quLGMqD!b1%2N2phIjUjwSu)yl zLOwK(Z;l>EKEeCw_g-nuR~CI@>0!I`Y$|e3o&ikin{_GRq_}!$)7!E&rkF4u0kxJX^W26KBn#O?N*&g9 z0|%4>Gyl1@^Qyfr7&oJF;|N88l)T-HBiY%Kxmokq_-CpNm^f$B*_vhDlD9Q!ZTQ1H z9+S!}w z*Epx{y{!fDH2*#>;YYmQpW_r>WQ`Kr4l^BJn}jkrLCv-eMM2`|vxzQEo2_rsdNpNr z-9uN8&b6k1?1fcoMZ-fu%sscvIiIJei5C}=eR0-9A)ldrSWu<5<~-}T73h!;3i0eS z>yc7W^Q@g;&2-(v7gwYVSH z!x6jSIU#PqJcV*RKHu9djOUkhoYwZowoFFz`ci{res=CYle=fhU4jK2@y%(%+FZM$f!G^LY{!&ssWH86g#^Bnc=fO7>+j(r>_=c|*kvoA_RJuT;hL zYGCqJDu+y!!1ejD=|4Q)r~-~Fb+|4^uqVt#f) zUK%W4V$}~ZyOwM=5&~iZ?&-#L%{CYIeR=j`8g0+(GW7&BtCR@ggUTlucz((ICyEkL zWoml{!|lGIeQ}TDtFh++l2Fuls6#{zhTHkYLf+};O zQN`d}o*!3Mu>Ou>1(26uQ;=R#=LKL$%mvvWxH5ujuY7MAH{BDpn$*TVOBqKsupc5= z&|W1=R8+CTrAF*r*e?c$Gz+%8>_3giygc7bh=dXynjo3_@bw?tz*Jml3^uE@pcSd}to^gEMxrI)>jIe6x6 z_-oSQ)t0iFlu~0k(7s0B!p6~7hq<@j%WCZxmAO%mY8&wN`gOU5W#2xSOn!&`ZL0=Y z`rw{&wlqj>6NfIVyzK3-Sa)6l`cyG>eeI)eYDnWRYh52-pZ1_Q@8HvT-+()R{c&%u zQiTwfE}Xpd)im5Q&SCDyXNn!4ha4YxHQy4uNYCauw?@D@!pSb55XHJ=IwKpcdtcg8 zD-56QrNk41J0F|ySbh8Lw^_24_l88Rrr3jH74ALr7E~S>LuUZ$lu%J-`y(I6;T&eG z9exG?X5PE8m}uK!CgGX+Y8x{wFvb!K!0JG*U%vn4%NPAVEG^i;+`k^?A`ATu%l@bd zz}jMiHa`FE5YKf8j+HgV-YR!*;I8oT?fVZ3ybcF3a-J;%7BgvWyDCkcj^|7yp{_a# z;FsX1js9ukUsc<$^>n_3V@>rvvG9j?evmT|nM2@2X$EfA^U8)Qz!uUOwgi&+pzP9~jsUaPNw2 zrc8J70yoOE(u2QN5eoEabas%Or(+g;r01YQla&VdiQ?K{L$E@n^vs>k2VEB<0nM!H zT}|QP6#LS~;iiVmsYh`EP2;fkvq^821}2iZUS4w^f~s3e-L5^g;W#wmVY#Spn*~e^ zPcdi~+Me1!-PIeao}yBm2KJp$HtX=a&!56K%Y*x`e>jAP^ZW2ae-4Lvndf~xXr9`; z`b@q19E1GJ!!jP#A$%GSN+BJc7n+yE=AKXnc$}GJY48NF=TPjs;2y{rc*MX;{Ql&1 zU#jb}4z9XEA5Sv3m+?7v@wwEo$5lY>cpW32@WHo?z zluh{*@F;6t0IbaerlmpcGVGWP2UFQ>33zhPUKo~Z>gE6MYZ3`U6p1=1^(^sRlNxWU zRshKay&X3`d~A~4cI_?>(ZFqZp-N*|mD;i^HjC&kbQqdR$Ke(V&$w>RoG}Y-lE!e!&?5j&O545PWFs@+r#yGLD;j-@auZ?K`nI zxGwiBdwZ)^1$BH->IvC3t?pST6KuMRvQU__q+)3TJ_g>e0{JhRWsx$w>MES5b?DCtwZyzcVsm%r;oV6zenkqC;1IR^z% zUDn29`QH1-bBZhO%UO6O>w<^(kKt-Qu?Wns*ITA=ISe^1nG>!0K6UP!%fBaICAlo? zfzL5+^MK$Q(<9k)lY7&^Zb8B(3X)tYuQR{W&QfMWTwWk(65}zS2zq(G(fl!QVo`L} zUQ!X<%N0Jk$_22zdfML7o`QrR``WTkGFU~3p8$T@S_>YOsmRHF{PN2$nO~mFgNM^YdY?*Y+1;A-oGUvQ zW{Dx9EldvV$87&?EFOo(R#Vk);O-6I{;Qw|lRFpl_uCe>(@Mjc9NpB@ zDofPClC-qXR&r&^_f#^-6k2V}RIlJjH|=T67163WJ6JMxQ}SL5)?WtNS~N(P;1Iyc z0>dU&aP+{R;vx4uJugAh5RUaRoXp%<0%MU=f7is<60rm6L+cDw9V~g{drR48%BzcF z-Ml7#1GUiCRLyvNlN@_HrvI0@F-k&5g1_rU1Mhn!mBr%{_?j{GJmtWSRWW5Pil7hO z*A(VVOhSU{L=!Cdy!D?yr^-_+uVo+v)wpr!H`Lv1ZoywItbK#2N};^!d%1Fk>XQ?Q zNK`ZG4@qj2xIRz8baOrP=X6#mzVcT=EtSFPIBu#Ln_gO317bBpf+VTxOh8z6@|o7J z_X|yXKPYUd@}O#F39!#wB4e z+Bu&Gv+X;$j;zlg1y?u`lzPIH z?PF*9@+ZP`kkz9}83n+? z0X|prFxT;3o?hzZ{+VhT|9>j7sF*(L1+!RH6wE4Lx#ZY}SxlQfE)1D{6OY@?d1Ruh z#plG?m=Q$}MT_qkJbJ+#->1mEiun0!F%PeIz6bnFOvq932Ac<8HOalq70esnS1{&3 z{P05pwwMEG6_R=Oa`}|oa@193axRtq45+`A>fXTJZ=q$DxY{0McpBCoeR5BZTcluP zz;Bc;r`pISn!{i+g6@QpBMFN|Ur+j#?JA8^sWl8G$X4zbS zIQj$hdV49-Jxj_@C8N>3MsK_ZvSa?B@IcXf&2isVNdYX;dg^A=i^spieOvs@0Y2Fh zfhkf`;LzjU&uNP5=h4 zRSK#Tt^i_3ZM#)R=kt z?8aFuo$xFihRt3v@t^BkW~&PJUFEfjB#fukF+1Wlg+fjk zmS}G4-eL1qd*oQ{FP0Q0wwb7=qMvOj_?Oknc3AiPwu&B}xC}mD_7qY9K77>-YKrW0 z%XwJzd-b^Q;A7Wb^mf<0xmw z3cgN7LASKO9GaqvBhNRcPvU;Lvd6xDK0#cn#(B{0fiKS?RO$KovACUA)An%+i>`U! zKY34~WtMt2@fs2z%Kjkxq^woUH?=*G;=z;)Y*nspfh|x<@%7us8@MZ0hrBmPiJsvD z;yrNZHx+!92^}k2}>R zc$4u$C|KOGsFBU`f1|(O4@H%;QkJx|z&XoUlH--l$8T=Fn&K-`{QAgfdR{sQ@%;M! z8d;R2^a(Xp7RT}Q4n7FDCqXk{^o)GtI%he39}(W)o4S`Om?f~c9u(asF%hNo*Io{N zov}~PRlhgd^OX*`DOdF8z`s@6U!%k>1x%Cmd`up91fn&@87S$20#UZ8xp+N zxk_iMZkak_ssDt>>G<%tR)V+})!t)O8J&TSQV^{DTN2#M99LuOJ`3O(*p(7=Itfl6oRn=Gd=~)}I$kV1TO?I4JH>We)V(Wbn@G(TyvBSrSi>-nJp&0dkjDS8DP`W5EeO=B3`b`1jqbF~FYC#x@x^Z!33lGuMk+A*5@XqbO8Tq?|30 zI<-o%&acIi%Qc@*MsK$sko)bv>E-pwNCfc=>Q*WHtDZq%D4>_TAp`po^M#YoKH=#t zjad4g1z$J@!WqX^Tf{#;u0mBRKHF*6<()js$>;XZ${3*X+u@5^Q3(9S zyga8R;OPV?Y733Yikr!*1Vi08XW*`{mNhfUxIU7?LJ zpV@RNR*vyKHVH1RkG;7HRm|)2OAdagoCbS0TG@d`hvwL0hzhvUGEGn;zW#Cuo?>5` z^dxN+B7=hKxYIXzRY~R(8P`^$3l?Pmk;DiC0RvB2B82fhEjx+6NCAzk!Nyon7wW=DZFRG=0xTg2W5-Auz0e~b>qhl$RNw#<3 z%Aw4g!S-Av*QQ);wsCBSyl1ykK)23K+2`WEE!HL_8hG00?0ue==g*Z020CgrWNOU3 zcV$6vU+%eM!1&rZkDkuP=z&cYD?o{=r{mOw_)mF0vFEO_UbWf;S*l@8X0T$n><7|6 z8`;gvd{~0tajr6oZAs}Gp8yJ6`QiPSt7%?DjH!{H-oN&AbsLYptY>X`KAceGDvj@H z-8-j!?3IhZy-vISwJHxkU*1CiL_dR;PUC@}$3peBm>~9cL!JTV1yKB%&tS;2M0h-s zU?0tSzHhcN;HoX&7od~pUF#AiNajOXmSeDYA3mg5RMr}<9ltNMOjPPPxeuYeP~For z7|k{$GSUoG*VQg~fBSd?cdu4{ev91rYaS=1pueP68G>zME~qZiLpewUorX66-eh$1 zCpw__q4RRVK4|An$IH3%{dxs0Yyim2c+VWKxCCA{Zy1r*a4c3#@PY9wNi?fq%H^Im zUTkE@`pMT4c;w)Svzwl7SjtRt=8OY{lGk6!r-wJo`0smB?TR;QKdJ5Y7*=0bJ&U{Ei4VeAB+yxpBGg+fDd2 z?E{!nFAsyeQje>u2GZ|IFssR#33SK1jwR?Skw&`wOnfp0n2O1JeF&$?08E(6JyG+N z3790RPgrS58lVi@Y8e}q3#E^%Oxe@7o)_PHmi6!<=v2TTy~s0jfqP%JVnB6Hz=hE~ zXPUR3w%Hn;F^z$Vz@+;sZ}MwTm{Y+-HLIe`bOL~+Mmai_yrkgCHUfz%YsT?Hw}#oc zTt9)VfqIvH;w5<)GEEfwxZE#+HnyHglvx9IBPEFZ*f*?b%c_^9#HPIV!-J~b2ACUH zb#Bxy)yRhT)pb6<;G$dtjBn?{}Tkc+d*B`#pJS{ zsqHa)j=tv()P6Z9I8m9H8+KOTOqdOo8GMgvcwSItGV2Rw@^DWhddj@QG%AG*D1CpQ z?{mYso^L;LZ)HzlzYe@NCt`%AK5m#vB|!Tci_0ekxwjl`Gb}{KF_1hHj_a7Uof4$uDQ<{6;WS(OiR@Rn(%X5R^8-$ZErVz~GxrT%~dO0D)f_Q{&6XZ~U(rQ%S zj(>ML9rgFnbC=GTD!hHXfxF)Z?q198_~6VhsyqxCeP z&&)D7DjAr2N*q5A7II-9z!ELY`yiDL0T0~R9KOHZv**s4RGv57YllrQjzKP_;6WHR zT9&J3K^txsXG({+ZzyH^asQ?9*{f8R`0pB6w@of7U022Rkt&fE#EJrGGsld*$e+iS zl-QRdG^OUS%x?icBv=qt5`)Tv@Aceq*7UXjzRPGqcpcZwp^H?RVeVe7<}xjpL4T>r z$3Y_+{WpE2b^g6ROj(d{XqM-?j6T1GfHAs?f? zq@KGjWK#OGQ>^us_5@fkPihk4DO3<=?&Y z;1wKw&$3_Nxc^8U-P+-l_Q1WK?X^FOY48y^+^2hZFwmZQt?si{D`)G~W`98R;$gjs zGUri%UFcMZEnfGwC)Indc>yTyxnugFPk3^Imwn9k)+YpM7*P6s61`?Vmf*fBpJ?{9 z(!EOhYXV^zWx2pgNquAo0)9q47Qro{%MN239v)BmIO)Eyjz7Rz2`CklUhb^mT zJ&#|093g-@*H+7dZ=;wEIN9iN9tuH27mX?XiX*mInEGrRtX?Tu1&zPr*mYL0kVeh!4>=Ul`6R2AeR4*`Rjhp zu+;O_tQvgJBR)CXTFRb2EgK|@=&%Qq{4HoPdjQ%ui2H1yr<3>$@_mYmtOuh}q-WU1 z=PT8*Sb&?-{64Ng zl(wNRCb&FB$Y$_RikTsaD+6d0)wTG#nm;HTQ zUaN`o=sxzF$`s4ya|M&njd>TP# z_V@3B9aCmA8a&N^7ECMAEd8@(V2^u}YY_k`ahQA}Cc-?C^BvxIhzT_=SpF@E`#=8i zkICvuz9&qctnV&VDG8v@zo`?ONasiUW?23P?*7gX1{$SaCk8{DS@78xUx~tkYTGG+ z6L_S6M!;2^P=~BB7Ly#!&a9|}NzXJ0Y)Z(MU~yuD0vDP^Pk8gbnZzv{I5XJ5`^(}) z126y`R1z8R;ef>fBa3;r-*NdkKRgzjhVfZyF6JP*?V1b_F+lXR6s}-mGlrlEevh+T zsGgQ+te79-Z|H-2PhBZxqSwmdV`@C+z|GS^c*EuXOWAm5>c5a@!k2?Y^U=}9>-^_=xrt=>)5$w1ANxR_GaxT%1^ zK?5JH3Jl{a!@vCO;o*IFn1t>T?`0Zzt63Bzb*HBvjZ;N zirHh ziO=v96%TLEPg#Hjzq+QizPWkI`@QBh=@Y#TSMdY|MDUnHumCV+0xT1PX!$)=U5q|& zcQQ-n{SiV9do-eqwn*R*?*j`E?p5K+=|JEO@6VMdmRE1k1I0aX0xE3J=x^6-|LT<5 zO9B*4n`nlkd54~lYtJ;qBNF9RE<-Zw46ew}4szlM*7P2&=gw#Ey##uq)mh~)-5+S+ z!Va*#0=;%cI~Ma1M8y;1tHGn3k0Pi8!5Z45a5fB6lhMSn#`RoU_M&usq1q%xH2A-L ziDRb83Ryofczhb3qL9k6w!3yY7muB-(YQA@)10L2na$$C2liD4cUgenc3ENr>}nhY6N^JqDnwfDR`>)+!2K7IbYoUI=gkSL0? z($gIG=aVGOsK1!0i@x`c6EkR2@II9+YQjQ6>_b6g##JnNecwawllj=YxvI+JkNLpuGWZ>Se}EtE-}3@L zNJ=A)Kn%#VTCB4>t?#|c@}3$j-b?PEpC^7M&r8m6^wNWt35FReZwIr2!uxA$gxNo_ ze<5NE`8nEUK7RZde*Wd(^#3JJ?#(tQR^x}nbn&esZxy^ZaQB-4-rp;$`Whd<)T0FB zahR%3V@Qi$Ch^PtDWf2=$`m-;3}$>Oza;p=2Nf%3a=^e%!rmK=Gim7Q!)CxrQ#jnX zx`73a=GxbkB1^qo*er1`pl$k!Xv*j{`%0j`uY^G#H%9YD#65((5wl1M(`QBXvD6Cz z0OVZSrVL1a+u9)+pZ!ZGr^RxBhB$}czdNVkoGZT=L$2zU#*wp?SX-*f z`Oavcw{`vK_)POoqNB>5v-o-)4k9*Fhv>T;!5QXVb04#w7EW$xw%^QOC&wrVb(QtZ z&OK4JNfDDJ&2=sraFBpKRd{6nUN0NkQv#X>rkea_v#+SYlo%EA`6%FmKv6}(-T?Ov5zgK^bEuVd{rID*lB5P!R6Zy743WojZ-Jm?m1cMvn}*$ktbdZV!D zSti)WWv}o(SR+v|J@}CKD^3(|P6vvrxe)#U31gcxouCYVx`0&v!iUy|W)} zFPv21s%E^Fc9)jx$CLL>-_yoaXBIxgIfo>1I;(7sqH4;$ja=Q&`XkBT55EJzx5qGp zppd7x;(E~*#B+r!jEDgt@Q2s{!0@)*r!ZiAs|$SZt6rM79~iW^7n`EniVv`H{!f$5Zf z^Yeaa{`&ZPpjMRl-G$i=Xl1-Y^!n1XR z1YK*U;3+V}GeF;5B=Bv6RP;SDI7FolVkrdd`HW!YJOI9`(0`X%q*#?tU+=!k>_dH& zeGDT=>oXcC&P!YisCR8u7j1lwCtE)fgHK0IXdJ3u9VWm!2-@Zp*XXs5*Lcih?Q`CLW9n&SlD&(0MfydOZ4 zZz;gDl(q(cetKqBDTZ11f$>!hhP8jcQr1;mg0p?y8jpKh2=9~YV-zIMn03X9rZ~g* zs`sU9=MQgO?|;s18>LSHaG+RnY>{*%tSTx0mTH`QpOe@4UEhkZj?b7Wa3ayV_Lzp^ zeZ76WfxBM?4keKdA6)y)$7{gOXHaDE#Kj*s(0Qt|{xTfOoQ2_RoA1})W@4}G#0$N& z`2Au5U4X$RvTdjev6XqH!;gExd}+&k8O87ED4q2HcaY zmPDZ%RaR8MLF>+f`-&@UGFN4-+hMKOMEg#C$SXOGlS222qD}B*;LQh*sfSN02MoH6 zIx6BEHG0yZJn6)4^fh2rQ0OU**zuSNqR90(R!IY`FBvaOV2=RZz*_RTbG8obW68a( ziB?Jg7~oBSYh^ucKA~4q@YAn$eMlbgS&;?z1;f1)-x&UuYQlwdl&B$nYWL!PR`-|yE&X*WPZhQdRhKn6b+@4XG0U;cd+|B z9J78nUm1d0Z;4gI38%fDWA5GaER-1L$MfLW#Iw4cS?%1p)rD-xN8x+{?=NUP2EHarnchETfM(Dkwk=%JH(OHJBLs z4d^Q=TJCMYr_*^?%)(nWFs&hNv`w{Z)b9J_N@`Z$efQm_r>vr9^ctm9Uu)V@IsCkN z?E_WXM7MK&BPBX0HaW@edphtk_wi(2SIQ!{6gIS&*jWwIkpI^uN+NNd2lN zr~=v)8nO>Z^nKXDD}Yj}X~Aee=Tn$QdbUP`?PsAtNl#O5NujS53O1nNr09m5{5CGFYi8nW4*RkDXS(8 zc)KOIZI|o(_T6&m$vuxZ1v+)rua!|rz+5kDG6mHY>aiR8oK`i?Q#MB*4yRnjk(Dnc zxc>Ah_RI)<3{^A%OiD2ywYrm8cgXlqwe7&y<9*_kQW(Kd?Txe{m2V(9nI=0$%gfI{ z$E1MJfY8?@d#lVZ13syeC5aopKb;Rls+=WXJu?ND@0~z3H&sgBKV^NKS~66|rwOA- zg>i{yQjaKC5?IX<&yy`FYCKODGJlgw?Qd!l?=~``MaCy7Np1Vfriz3Qk{l#I_B#)dm0`6diFdyUEYt7*MV#zt) z<5)MDj576kT$L6%BHT_Lg;(06~(CfTW3j+IA+tvqc-)l z&8=26BYkspAgA7()tF}hgq)Pip51c&U!I;eVrsIUpn!Ox^~dLFqN~?UmMG^0o_vBf z&U=Jcg!SL!n1Or7JViFr(vKU!%`r&H=a4C(9xQnP@88eIHa>an*9okG{M<~;2&X0r zu*&QnPy6&A>|5xK+xPB&&w`8h8TN_=81iQTG12!MgR6q96*@28;{V@E zax;a&i@y98%A)*@W=kkj#(iC-jJsD>WU#?mI<7#KGNr!9ZclF9`xJ2%HEwE6@%gX< z9h;1M$vEcy8_bTwSmx`PomUS)!bGzNMd0JOFK*YK@9F~A?klvC&mC@ze z4#!wEkbr!&o*e}OMhBFvWgRntm-|I~TH7WDOk##E6*E0(0xGE{AaZQAhX>D91XVCz z5CPzO_ToGxQ(Z3`u4|!*YpB2Xc@<{PmERy{1fM${%jLg%jsZyQ0To}gyMnvE9;_hO zY^1)k3Q`sS-IC8@aMlR=IZ##B(b3Q|TtkS&L{)-~38dMX4%a5oHm1sNi4vVa=rClq z156pz@er^`JzDT{+prOEZIHQ#nj8a3{#{g|nyp_U|DAxm+2#f(U%2wUQAd`!eK@2s z%hWJYdBinXISLE{1b6}twd!+UX`dC-KLG-%2XZD_W(^7@|GqoB#B+6ce$M7Ks&DfC z4OMC~Iv80wr05F4>*#ve1aK?x8&Yqfz86(C`csMDzsV1Cr za~8~^hm~oPoa_>+m_Lsg==dI3AJ}q_^Xg5ywoDu$NOgq^ z^_6um$mZ24*ZAPH0p;FQoZ}(@HhEqUJY&%3+b6tLluwrLc`f6vPtuyKC_XXTP0 zfa6^I3=S(9VPj)SUmrX|DGAcHQn~XPIrf_K3W=r4RjIP)K^R{*_dyP0zo8`D?w5@B(-r-9*r$s#uKY}ReEs+{$K4yFvv(ki-taha z^^mD5zCzj5?QY_PE01lHj{_=jP$R6Wl{y<5X}~jjn5>Bf_%u_KnPS(~5|}LDZoK3f z&ZKnM#(Vtv^2vJcrcAi#Wa^yPe#&UHy#7jH&P!^upb2Ma#l##51r8`A8Nko+=dYhF zaI|MtO<5w~xqps5cXJH>=Wf=7P-V#%5uC|RI96qpu{s_y-?qAT)wAcdvgCsd{VEkZ z36zaa!@Wo9NhILUfXZb4g+5VJ6n}!JX5H-09ZhZsEem^)OJeCbN@d6>yim^6v6bLL zfDZtafxnrOQ%V_n_po7N%tqtn%su-;rXWn!EytD0NHXJ%Rl>8N4Sz#Y^ueh#C+d}q zxv6Syl2=^GBNU+K83oXome?U*Cyr(_CTYuenn5Kk| z+&_H$=-lJIGl35ETWoAvuIGdVg_X*wn9o*c6-zs}+wPFHD6rU+KQDa`xCa^ya0SagTJFxn#WC*%7YXy80HPUV=(<8Q;CMsrGN_g9jU&s$}|H$4Z_E1(=x&0 zJ(>We^N`hROI8D3@WuPIc}szpm#57=XZsh4yfNjFD@fIj-)5?e7y21JO_jx%_-}n5 zzVGK|b`V?7U~Xc(ef2a2@|L{D^Yp#Ju?m*Q6|BL)K6$0;9+C!Z5yE@TXjWQmCxP=+ zSU;d!qJY6IB9U_1XMh<%F!nXpzuE@%_VEVpUI{?=J?~xvcfWPgtr;n!0n}Ai{gTZN zDpuH>0QR6%$(sQmVzOWmJo?NLz6V+W`_ORaQnMpQ!{E#uXRtW1K}9O{q15Yvz|3iE8K^v)S{*A=@!`f`hkMezpo$mPz~OOue#!0^ z2bvuENoml5PxXbfO5j%u?o0C9o>p5@?gX{tKs|2UjEy7#DpLL#ut|F6-(>H_eW9hw z>ic&lr92KX)T!L%4A7_4CTZL&})(@*v9;6b}G+X~Pc}-Q{?9;qTs*zkh zg7PG)DCp@zke5uItwFLn^4C3u&Qy2T4dwIc{*Gt{P?JUg=v2sDs}cAJ&9_ieU!!!K^9Ypv)7+_DfaAkRqUe@r@yWf0B@9Z1#l~f1~^XDvpFV}4!!KP%%rGO6-4~*QV+E3 z0o8gA-z|v%+8pn#3`)7`)tI-Po{=^O5yW#_2$&1FcYdwZ!`|cqR1BB^E)g#COZ< zXbTUjbyA^Yp_NcYs~dUFvQ}^XU1PTM`J}+}+F#z#+8en0`#x^da(LA7@ST>gqx9hn zbC~SE*n1)Lo?5frZCxdbZ)Ap9|5lJi+!p(}*b6HudQG`aL0i|ExidCqYCX1amDd)i^K!m9f+$)9m#^S^^NqL>C94s@P`M^<@ z2b&lGkbHi4|87_9DrL^exIGEAz~s9l!Ixp&WU1n{by^{a{Z;8bt9zA*CG@Id*0$nn*K40tXO){ESv|SW z!=zRS(IZX{^C2ZfL`FsNBsgsEZ|r`rBu13Lf4ppiHLOEtRlfaSB=qR zjc>KAk881FBWtbFirf+$EbFKylkAB+6b3`-iXx@XT}^4r?HKBf*HkM%+mNWvzHlwvJh0R)f-)W&S+9Y!XwTou&09 zpN|irA=S{kRHko3wzdR#H>e`lvGO=8-E@o~Hbga9ss0{5eAx7{$(?n}{Fc$XFTq=5 z)nJ(@^Rg#Z27V9chiKw%6>tPq_30b|mIS`)(^)6l^CZ?3lYvrs*78-x7W7akK;oJX z(I+s`Ytbty_rHw2sALK|CW5|I`8H9zmDat0%*&w9yM8<_`+xwCi}t4p4YR3dt%k+o zp^5Zdtf%YScSQjzJU;}Sd({~+O-Ar4b}5`Jldo4hKUX#4YX%5@_q*T40DUmwh~}Vs z*L+#_z-67i3pOTQ6Q`O890`VQm-~^k#{6)rVF8EBy!fYj2!DF)!{20|TF$ngo|m&( z1X(T-m_H1YK7!kE*4o{yl=Vr4xvC0%!7?9&ju&O-v0tOQf~1{RN$$hOHi7pu3Ank3 ziz{GCxoql9!Z7}veN^xI|M3iMRNM;BX>AL+sPZMZghVCeF{>Q;-aRBsy;(h*r!#Gy z)f-D{<4DLeaAa!;FUTg>%=S5Tjk#Bml@Y|Y@*cVfvJns6imgE`co*-vrbNHQGi!nu zf_w_ZuJQHc`7u+(Q$}z1=d2aQS9oRrKOQ@sQ%Ccfl<&!X2nhT1^N(rl5d*2s*YdlM z=igZ+?h;;}zLj7_+4ou58^D$)Ts*j^b-W0v&>=;Y0xfiOG<(OB*`O@QfA zzXeytO0*GNKWGhmA1o!!Cb%nDuPnnDvaIG{zDZua6NhdxD<2EJG!*QsLaU<<%FoZ{ zKQ-KMyA))t%$W}p_XDBosKDozHNcWxS?I{|H0JeUN(KUJPuqv z;r=5eLs-p?tD^{HMKB2JnVL224r$KH_ocF@bM(a$9!B4i=kp;nYBkX>0c{uV3XF!9 zs7Lj3pXYbZIwA(o0`Dr5vrkIAN)ZcLB`;M zj5V#Rkpk?DdZksrkoSAxXY@D73{?xAeKU zVO8^_HFQ{lz+?A5(h;XRRR;Ph?jJ`3D*ceZzwa+9*&SuiFs!P~V7b5?T?LQcz1yYw z$Jd_H*(Aa4eZDKW>-z)COWAwM?=jLQkwEKNNH=0P+$LQFp5^ zU+!`JU*X#pj)gw-b&bFT9OoS;oAo>i`FVypj@Aoqvp_t+08e}~`7F(RF0FFLNk(sF zz{-gnxUW_R*X+JZCfyvb@gBl`V;swHOoC^gd|L}v7@jf1^NUTu!MtLRTOLE~UnOs1 zKA(L&#PJJXI}58}kHq*SW)=0Y`H;kK`lNZ)b1>x5+6h6QQC9ecp7(nhdB(s{E7jnTS(6xCr$oFhd!0s>rfwVn2^$M`b+k<2~=eaic!po}=@s(Y&fWmu_kGB5i`9aCw3^Ioe&DG$>5(lbRpd)Z#8K4Eo6tBk-h zq(GkgpAtxcH=Dd?MV@qcEvkHWOYl_NzLNF7+3zpmhE@8yNb@rWL{c|hz;kT@ZAt#T zJs)$WNA8W2??*@KV3Iz$nx`J5tIT|&>&ms*JtbNh^~-T^d~Uk*p6XXfv}}2ASPAI5 zaS6KG0C#W(!kOriB^5HCPBNAjnk}k&32Xq!FToqCeGRH9)EdA6X4*$N@Y3gLR79g| z*3N36PtQ~OFz0Nqk-byEov5SF_ptG^)a23qB^whTEF&Ogs%+NNWfcOi6wN|q-U^6& z%aAyNM`2VQUiX&p^mTc$TevmxJUiYeoi($KC#3Mdxi0gtZ?tl+_hJH7BCJ$N9k*rynPY_=O@}On99$Tdsf+$y_ISEzCSVUxpgrf*`xA$@h7cpx{RnpV>U7G*;?B#2Jr$lca4|1kHH0c{XFlR zd%t+&12|(&z0WMNIwtPLzc+vS>MZ|^`yNLUOu+cT1oSm#E-H_l0bVn0 zb(ST>Gv#WiT!%;pmq0)M4rcR69B>6x55L=W0~|T?%ZC@7g9?W}@5lZuxdj5Z#ZyO{WP;jBuN)W4{C-;-ERJ)zfIs-Wrtd%LHgNuCD; zS~^fZ>mkv^o}MnD`LKW+8H*|cq7+1{xW#hEx69@|^?EHB>@0xMijdIosvOu02*)## zz`Kn%omFcfRH7AQsT9e3$br8Aht!M1l|xAR%i7%&?10i`oo&b~2udc?wbBC*2C~wp zsY5pK*&_>shS?ZU&@{UQZ`dw^A^JNeV1l1v&L6BY8wyI5dNx#Z77%GNf#;C?z4hr~ z&2g{gJkD#Mp^TA?CqSlDTqXJCl!#Qdmu{ubVH~{xSJo3&@Urz)N`L?cjsQOQLfgwQ^3AJ4#$@301@FyOBTm9GGo~c$1K@}Ixs&Y*pU*u1x%b_B1be#(23Xu{=QRR6 z;9*w73sv?xQON4!yyjU%1`LQzOzPrLZ;!C)f6;@5(sAnDGq*RgW(DxHfS6M&y-m& zefR^G1vMSTN821vjG?>~aTOFV| zl{2Tv?jd2&9hU1kSL$asEP(4_Iz{js>LfxS9}jhj56Y^cp~h4Y21dBhOzy*FhWN#6kqKce4hla~d`s%sRJg3)qKP zVGyvu!I`X&Zos7k*kU8(%CPP6A+!QK?C>5< z-4NFbL717rjR7fEcblD*IalEt2zHQ}dIE$^m6?AB7o;m+nN(7tN|^!`r-&#Zr8%CW z*|@BC6I4o7L%aqm72|UjbV6*U!CZF0V3R3ss?;Yq+kEe7y-&;YW10R2D!eANGJXE4 zikKVobtI$!_8j%FHswmCT|&hYYtN{e$>)+Poxx1%Tf5ii&!1No1QanXd2$rmt*LuL zJv3D|?U|wPGI?ylq#el*OI|hAc7N6}Z%2C$@{A9$zh{yj*Js;X+i*TrN^g!qpH+0{ zwP(p&$s~5bPVmRScYZi$0wi9o(3^OB|I29}Hfq({cQxAD(2A7ovj%d<*h`An7O{zV z!OK2;lfSb`@X%D~@%% z$Vp8+6Mk>J4ictb4Vrh)=7 zCC&{bemNdsaE z7RvFJ&?*`9;#tYLBrP@GT8Y~>WSr#h)vm~TKfPVl%k4>@kx)NXxx9)o;W!Sz8oR$$ z?cTuM>y^8m%9}qB{2{>yt!%#Dk8TU@a@EVEywp}j{}eAHzIT0hlG5GF0KI1LjcgN( zf^g$CS2Q@IgC2-?j}O@f>FJ?fnwJku?-^7AC!jr)gle!k@*&`>i>ORu(`7#?94_9X zfX7fao)TEXeWB-S?}ODx<-M`Fui`a042FykKbRniY0UXMrXvay4rfM^4vJjZS)z>6KHHo-+czXVvAKodzw8ryR4vJc< zRGH$UU4wv+hh7RKw{YkVOVGCjhxOWA{v2K`2@nJBp*gEy!|@@~Kl<^K9hSZd#ug!* zFeurEaD{iW=6Uhk10`2}2lEN*4PZ{poAqnER=+iH>BX6DHOM}+wl0JYH7wUC^RJYx ztioC)lldd_4!&f($54Rh6C|?vQJgR>s#tS4@CLJtR`FUsE>&1Vf_N}1Jz1fBy~6&Mu~z*JvH_NQPfp5Bj7 zGSt(M{#`jH04F!n{NSEK`I!lpWRy{=jywWvo>ssb%sgHz8}baGbcwaWVAm>>qa`sI zxCBeI;h8~s62X2F&tWB2vqhL4MKOC_VrDc)Bpg<7UXgNh8lO?-2zj*0{8sT4Q`KGm zlb_uW>p7wxVRhJ4V?3bY>+!wxFnRWUU(B}g=NYdLfTH0V_gDE(-ts1PklityRS|Gh zs%AP{h*eS_jG-dqD^sG5yX`4G#mMT-nNA3_|{F91m)groPRL0MzS>%6Pc?G ztAl&=aK4q;N*FWW^UlE73$uAuN`6ng9w#{gpa8HKJgJ}>^|Y7F&bcR^*CAd5`#bmF zV?3CO3bjc7kl$e|93*Rfe8@o2&qWsO@hmAmgT2~0)_|x=GP{PAU47e1sT~O_tDG3% z_)LHn67o=z28##hFN?~dcacT&a8DR3T(9;)&$;RST%l(#>M2ZNEXG}X|NjQ?-oRb4 z=gtE@UlA%*$GCD=0sw2^Sf$J+m+7mv&Ok?rSN&Rrj;S*xVGKSD7@%?g%APkLQyD#N z4I2VPO91vD|IJOzo~zI0f8KofefjXrdO93kfh$TSUoutzWhE#+Z1#XJHc3wv<=^+T zip@f^1B@xBJg=ZW%AkHvyn*Q>EU4oBtGwj}SD(D^6Dp5hAc*Nr-Y+T>m4W$oHRtqW z^Q%fpgK13jM8DTBhuW~ruV&VsyZf{N)%LDI>pTcxjL%5Se1(>I7`v#tC*VYid$sl6 zx!yshm&6N0#1v3T&|?*YbH1ck)|yvJ9f-ZWNy9;eOo$ogPvQklK32lAsFBFR8rfdqGVy>(8rJJAoa+okYQO>oZFf zIPjJ#XbKYgje$6P-$pvCtUCsfcCU&#_&r%% z#)D=*Hd6hXqkzj~Nw#D=U~Azd;L=qdXQH*8&yUf@fmJ-Y{|6O0T%%oggPutj9Hud5 zdl%bV*!K(c(N@$r?VcOzSJX;3fu@X}$;zn5hZRtIdai!o#*LIR^|^uSHr%YzTO~me z4fGFHIB4K5Dv=FY9hlnT6oJE~zi%j+-pj0H0*yWG>FGHO`uQC4ezyK>((@~lI_*-t9U|J@w zffJ%U*SWHYemm|370{T(!Kjy!sgNu(!eDhz&6VdVVji|~@T{tM-bg$XJAz^Ajg}5+ zMG%!sPNc`g{In5J;rHP4>GS8$#eP8fl&Z5NpCK5=qE~n=X?=j87ign=J`eM1qooPZ zLuU%q%`U~VRLFRvWxj#CBDgDUPNizeYjnuHir~6w)En(J`rIih#HTcOooc&c&3Z2;sVb#QR`Xut}P}&CaB^M)r>~ z_m1J63IE)+=Wfuylk0o;&1pkRWuPro5t-|fb!25S7C!Rk=CA|MwJ=VJwu4M4SH~f3 zeVom2%JzftZsJ3AyNuHmy5X*%;JJ-^!lS5%&LYfEm+9I@%dGAB%>ZfC?*kvlM5DBd z(&$w01`rl4)aDD{9Wm%9{$8dMd-iDa=OEf_b`9E@i#Qy`fi-s+L#> z8eH4{mi?aWv+_E!US)rh>%m!o-a=W24%~6j#J+f_K#Ne0`Vq?Wv|zO}pFpkdo}zt- zR(7dJ@PK|jy2dJjhjH~gX{-B@Bp7!ea(x!jwG%~@TMVwEZuKg zRr`#zZDW3nv4`?_yocj*&(a&*wFgZ~Kv2b>;kpM_Q$~BowI$V2$HGZM7IuaRxZ|o6 zl$dpHF0UiOJph2O0?F5}&rez65pfG!J8=cfi?6Y`6!+^f3xs>bO9^XVp<)2?nP|tT z6m$O@D_kNT1XxiuTB(>@Y~ux20Mz`NW-#ojpPt??^M-pAIq8nS!Syli6Q2T}ydDAW zfprIb{~;@wvp1p_KEd_j+HqdUc*xIWe7QJ*3Lg>#Vih85M8*?mpWKHCtx0V8>FdvW z#v=agj+m*+ehm4}-du-wcVL@$J zdE>gFwo}S%l!P6yxLK`_>4zL__zDXzUM}}@#>pFVa+5Cj>|Di>g(`~@iyT1>n`V37 zxCc$#SI7N#06CCwmQUFf@O}201F-Tm92RwvPaIkvq;r<8l=0(d%?FUr{32-QO_L9> zJ(`e=TNFDuCdvZS%X$+cK*o!~qP#ZDc?I;a_zVtmj5SQ$xtEOT!qS`Nfo;j;oC78f zf^PTE$>)yy37cxp`1|nDOH@+vE*m6Bl%A|k>69sWRR9o!NTD6c6q4SKYP77j%z@J~ zf0oaezg^Yu54ISO^|IEc==p`iR}br(^%0(9V0~QXM=Oe!;uFQ0(^?F>#e|$df%Vu$bMkIA zF-K%5YjRwxw@ULAutp*xUd`@mmAwNDvH=3+ow=NGRUjKw3biLVipbAa`SVN-Q5%FzKc24wA>4}>Qh^#N zk`~V|N?Sd@dmq8-({rMW>sq}%Z}#O5et~kW;Ti$8?Qcog#42R9(8^@bzuz-2zZ!q< z)ctTy=$s_W0{wh>*|ZxBq{f$2M*qu zLtp;y6#AwQFPE24y^p>#buAhYhPDAT5%`|)fxo|)&mPCl^8K@^W^R&} zA^-pSty1>}?)FN%B@q*yWh!5F3IrGCC5Btn<_LIRPfZ9xr-Pn8)P~&%*GRTL(UQZl+);v{= z$C)|vrRU3(1@67#&6D2`V~fnFWTkja_^^wax95#|DtzI5GQwLLpy$GS5qae_4`}(> z->;Wl^K-sV@41NaI-ZW3{z-lPI%IUEamafLkx)Qj-7f&`-rN=Z)bmwonHp?8NT0<5 z=Cn6(4Y0+C`+6P1$B#dR$BXm@+_DVn`7vJCU&k*BB*haC^F}h^<7m&-*^T(hjPFC> zpbCK%4p|)jngJcn+N3+ALmR;Y%y9KJN6?f*0(Y!f7U%sO)iOg!bSyOp8|xK#kYGu) z8L(blN44Z@RgsKPB};>7Hcvfr^7{;`#xYSA(|FY@%`DKoOf(+!ZMmMcl)$prR~1Iz z*JjtO?iZveh~6*u)eD6{fI)g?)wvoydC6O?TGh7k_oT=fxTls>Eg^lc)L3VI!*j@2 z#?w9pg-#PNNtF#*L*tkPQ0^oMb3lKb>=Q!Q5*iaFekud7yk|?VUb+_o^@%=7Rth>F z0F-gRtdbds!fIdJ{+dyCtIc_mTOw#8^KeM7aeMx8wNRKR!{n?sT?RGM>!`HI?zmC7 zy||D zLEgJslR8HeV+jxOdJol!47IOWFS(pGU(F|xK@X%lx%M&2M4Uy@9*`VAZ=4 zxbwX^o+?-}D(4LjK#T<#By*=5#Fz)s{W$Gj6Am2CC~}5Jm7I(|;SG9yiJz-ES$|6b zwDLxZhIf{ThNLpChYt%D_mB_#E{mUd(8QZ28)e?fkBLE{SI;U1Pi%6|m0Azv095xZ zCzuZEWz6M1W%J{W5x;}XqE{@%doz7@a^6>^=6wcPrEA1^f)2xKVm@i%pYfhm2GeLu z^ap;uYO}V+4P9}g2CKoD^rncSW0mNPy5om_iHW2#Flul!imI%&+{xed!qt~%>{=>8 zmT;JF;ns^+SECg(y+-kS3wfUm`U9iY$#%_gP~v+a_vS1D4rF%aKD0t!H#x1hUXv3l zmmQ{5{9^w-1P;-gNbY@1047xcL@BMxEeKNZkGbf2_$ujT2xOvN%{iz6hy&dil`*4h zX3yLSop9nP^ZzWFM?(!)f*Vwfth$(#8PTuDbC;DrWlsoIX3EZ#qbNNu+C9;SG4Ngs zfHRDFuNeINuojKhnN%$CyRr`(%{4thd2X`zaW%~uDtjw}u4yyxKc=v<{CWlIruZZr6+D8nxmHuT2QlrDqMAC@ znIP7oJ*W^_D>eglXTZ?>-G;TNx1_S@&8WSxHNLXiqX!WPa7#Y0X)kHEKO4sge#FrH ztQC=E4L7Km$Le>It)GpOC{t!`a-(mp*3Ef8bYi7g<*Ykx1WmYykgITr0X$8=)JKOtt`>cj0m`e3Z2~=^tKB*(U)?^9=I=v>FDM{MBcyd0wy& z;Gt{sxjw8_YcG$i_dnoToBVKA6+|rwEdkx~`j*YU^|w$@F__micZi1r=pE_c9pji> zrb|3T-lN%^5*Orc*;+Eek8#PD$*YlKK5|yJw3qmK#o76~tFsEdROw>RqP)kXCgVCx zl@lvbG$^f%b0#_hFR{+(D+39QL@+dGneSs0cGr>yKUP(kyrql1&)|ZOYzzb(P?f*5 zcMbp_0HS;^h4r|hWj5``uB9=rHysO7&h(Ub4J_yUe$rgDAP&L37pqA0)F}tGoD|4> z;^?|Lkt5))WC4MBf^0YX1k)HnxMdjpfwq2?;F^3)am};#$o8psbdUX@zs~@Y=&tFR zRMRdklfkk8>kl`m2r$-ZqGTGck|`7^E?V3g-u27we!6M zeoFp#`iv_Gs;rX^~?5bsUYIk{cI&okdMkFx>K{rPgs zz>;rk;A$Yp9XMZxY201gNDgyi&kMeA&pPi@Tp9Iio0Du_=*0t}QqP&E*YdvL*+rZj zVBpEt8UCK|yX-ma&r^Jr^^GbWv#c24`oufG*Yoq&qL?3mFs>79B3u{LnBTqokgA8W z*Fhseeumym^kzRPbvP(hQ$7)2Mo-qK1pH6|M*IVMrl+*V@yrVh-nL;5({C=+yaBv7 zaObE)>t?~(Kc*18_Td$}*1$I;P!j{GIURUj$?~-i&dBiQg9QxEwpTntPXL>0vPTz7 z9dowHS0^}Ag-jAMHTu1A$a?NL+vTa6eyn_;<>{x`pk7lx<1Cq{kb>J?TKxFx=@(wY zxTD~IDpViDJW@?DNTo1sjS9MHk zZ*{w=Ec!!Y546Ph2L&lV$fQKgG!YLPbQ9O>yTpE?(R}|@K~s#UV*t8Dzw7T;RFyeO zkJ|#S>r*%fk-Q$m`ScLZ%~1hfJtGlo5+3H~wG)9z9)-SI$Ka{1HtRd1Ew(oP(z9;9gcDVo=DYRC-Djo9_I<2Y-)m9W zy=$m4sVZ;W=Y|fw==q-SD^S>%vHz8lEP7c@y-6hU&-Z%a6L=W%o^B!jMhq9v#GryP z67$Zeek?ETZGXN!T47v?Cnc6oh>r2tHN_Res<=W+Ac7}$(+qdC-nS3LiwmiY$mUd`5(d`C9HLm^w|`)AEA5jemu2OUzKy4_#014oD+BKSgp3sj%v&!{13jmy&*i+H;au4PYbr<3AP9@W2Y_Fl;_AAa3JlS~NL)H`F z0dUr%MoAE^;&E^5I_G2NQYfSB=`<0&TC2h{vikX<3;FFz1p(F`Fp*bRp&J2w3&5+| zycaMaJ3QN-;DQwiW^3|t3%9Xc^(oo9P=N0f5fvzUsG5PsbU3W$(zhH2f+F}uII&5nMK&7QM&z@RZv;*U|W^9 z9za!z9Mo_;CFSVZG{n?k^~(gV$l3%cj12`-z`gt)*>}MDLaw2b1PTFhRUW0eo&jgJ zT7XT%saq?0=6{zx=M)gHy_~u~pfVRs1+{01Tx7uzexC$lf+ewLW7Jf$dfFYPgVIXF&}Y^oQ65-?d`#>t0d@VM^P61PUFxN) zW7TaqTJP`6xQQniL~$U_3DG2KV?BHTOOx|21i10%k_Up`C)Csa860r}mDM~^5o19j z&nV$JiA3^iOe`=d z94}+d62BhQ`pvy$1;HP@Ir~5Wz_bLASlP*Mto&^E=zi!YXqt8dXyI402ekNkKb{^l zQ0x^iLCe|mP%P0tyhmfHa_NCL_d~=g+e(A=y;wS~ItH=ls68CRxjKi_;S}0IdgO$1 z7K6y=I`-(OmG?YZwJKI12PF|5*iS#{vevM3KO^~RK+-vumm5YH-Jf}n--{}J?`HWR2vENW1 zUF~S?>hs4o2n0MpEA(q8?R{ii%t3R-rsuNHao}bBXN~TUW0BI&KrK51hGDIG;yiI+ zTPu>&^lGL$y`SupZhuI?M#hHB2)K)im1pg#W2z=7ns}~1{q&Qbf!x2x3>Pq&xUUgOaP;$WQoCyM=lJ)4yEi+8 zH*mKL^7cMU0iFj-p6cKOK}|~N&+}?wUDdC0hC$!stPy*UVNrRtOn?o^wy^xMSIaC> z6})se1EEw=u-`qKTH+o+_V4G_u8 zPolH*=e60~QY(V`yu^veaA-TDoQ*1~A}W)qmtrQ0@H}h|WIRXo3v$5V#cc)xL`>a0 zAZWPvxd+)a=ZbV8W=zl4ZzJlOdN1u19zz6sow~LU2?zj0iO1n+?-$s|O};nB>(kx| z01*Y3%Y9j6yB@S=3E}5Q)+@$>E7bF)e1vOq5uktkXSYTF!>_>~jmCc^-BHY|tuS>!}Xa7ToaPBOvt&20V+? z`H+E?u0qP|NKZa`-dMbZ88A?U^i?<>Pd-2Sec0!Z6Wxe^xSCb!d6Zr@JX`j$ zOEF*QH&#elqD*W<9v@Q+56(37BckU|;uL^8+>i9t$?E~^0nlNOX38q)!4O}8xC+1> zpLyIW^6>tYJ+}?zKUBXN+`Z8<-@si~1{cmh`x{B{g`P6zvU4Sl581AL)D8H4UxN~v z)W<`k&7!g?LsUZ-<#^AsE8~!R0*R8J{7h;Ux=3|a+1Y(_qi@$n^VJ3$Yc)cO5@1Nvx^itaX zqg4Im%?8|c4~j5W(dQOmV$%5{Kraa{fZ7nm^X#m?TsWMyr>pG)+J;1KTjj*f_f6)2 z&?Q$eiNFYP;PU?6DFZW}(+@dpG)gnbm(Nr8pw*~rpJyPYCr0iEf)Mf9qJk^W>s>g1 zcvvo1{E?o+@p%XzWM!O}`TThq%Zq@SKJ?#w8~*QQo&2BQE%)4(5Wuw*JFrTy!uWF{~;bzY>R(v9~seScKp7ZsV0x7LJ1Tyi38X^M(_}BTLjjMVm zi!A9Hqdr?bZ1CDfCDfn@G|cli`a0LcsP+_-;hFchSp{Q)7~je`Kh*jh<8?1{;Axb! zdaU?J1HX8*F`lajIQlQL}Y z--lM_#&QkgvaU2xmxRLdURPTe?bqiB!s^z*x9vf4`5JsJ;~)V0&_&aAq3@xBI*Xxr zs{r)ge_7`1GH!?Xx;If+ybjBpf6yRbDpy^#%p)=NmHx}=7Atb|vD{){W1o8N@Z4k$ z3JpyR%O$`w6J!qX6F|3wK@~!77lBWrY%zF_{;{#QuMsJBecofL3?`5*m4)GRsF(YD zxW$CPC_QO14hq8ixE7_-rHQLnTTMj;a1g~?QP8d1-O4V4^H=-j>zpZqvjIsm-v7~B z5%&j6Zq0{f4xK_*e+kX?X#q=Lf`qI8@4Gg9d#=NOxybnZE{w}_o6l4D@?qH*##{LA zFVFG$y=$l!cUF7P!*We0>9wmGt$23YyJz4)&Q4L@J~X;Vg=yIzBw^Hxoy?r=(cWKd zO$G#=&$2EUDDzo{Ae`4X)9i6(G;_N-bNMV}?^CbdjTppN=zS7e;GNAN7qVNP+fiX1OrK7G2TUc8SV zKZd85=ag`Y*OA9uVl|QpyNy$L`*;I)#flwM$Na{$C#X`YcI{@pHN zCZA=@GQ*TbV#98xQhEM*aiUoEj+>-&W6_~#48BKe;Ei1mkbA!wZ{F;gv(1&#B=%A@ zS+&KROb^tT!WqkwCr+t4$64mmGk}i}Q~R)av!D&zMKA|m4p@BOQ!D-R`~~cv>WQ2qm=>}Mk(!})t$bNAV)TD^)Rz_A_2yA znPV4;!xr%RwYNFkErIXzF?>0;={-wL^DO?OhkMoKK7Qj=eD=Ok-jDGb^le3WK)+Wwa{#nL$p{+-wqNE%*PB?$d>2XF*xM%*N|?4o zWm5hheSa3{H)0Gfj0q9&S$?%!0+_lNfc+AV!TRh3j0j+qXD0wfdb{NBEm?-D`+NCa z19Op{(Zs($93!}1zUudH(GRYAI9ny|u7WChtwL*hkY})fp!yPNmnPA#%#Nx_Vja;^ zASQ8CVCT?n`y~0_2e(||iVm^c+Y(Pm(B4$#7i`QFg zB6XOT{a_k!xGsO!uhq-SiEpKfS)+C_@S%kFrS2d1VMAYJ`X9g^(>?k8X7F38&@yF? z&y>_p_A7Cb?`8HM0B3umH>|MD>?MFkZ-wFe&-wi4wg!9!3u({f9Py7&(Be}?z#MhA zWP4DmZlbd6`{{TddW{37tfH!%l%I)-#g#(OO!4o}Y#+oXxE`6qcwGTq0Hx@m$C(e+ zYP1QV+9}C*ehzp)VX$cu^cI;b^7rz)NQz1#N8`7-&z_(6qI~;!19wGmr<=Cp*Y8pD ziZaS!YxoU$`cf}gT$JHg<^F$bBdJ$6-0O$oO(N@)`4y$CQjp0Y!C z9R0xx&;?qrRHaI4hKEDvz-h&*^Gm>S-+1`&dou_w3J#^LV{P&Cpqa>+C2dlc8}BXt zcjDco+4n(=%ja-g0@>%~nlAGK*uoed+c^eJ%jL z&wwHJCQzGXom)n{(ISb>;qF1N@#(&N^SF%J@_dKo;Q#*PW9Z(043{bf3_=}ZYP4jW z?++g`+4Ac2m;xD$LHGG7bm6qjqfx6NlUkcd&}srutx!-qHM_rDq-s(tb*Wp{l~knu zJl>McfR0aXD#ewVBQKy%sPQ)gVdsZ;8o*qa=PB9mho@UOiwK7XS9R=xTml}MH??x+ z2CJMkI%lU@=Kb5Q(EbYG&%ApRuRNR*R>eE<-KaESEdRz90sS7vh5fmoE^rBSK|6`77zk6rB zzV9ob%QHt9h;j1Bp9wyR$orb#bNuleVRx+_yk*Pow{x(s^0j zGwqpjVik$N^=w{y#!E3GUwesx^qTlbNwCdR5D$lAx-Q>$$ZFRdUrZ!41s_D8)GhT) zmc#*}7V7OM1a!;$|MjnbP4rk$F6Ej4YN3YeTa-?x2<{R9w4b5Rt~SQXbh#!b5NObm zSz`03bqe3rTcz#|-2Fy?Ct0ylzn14wzqT2bc-JL?juJ@N^U!(CSTx%_ruo%t^qV*T zo3oK#kuDmT>?3&RC9#c?`8U%Y*XH!Tm~qSkb*F~KJq_KtEBgEJA-w5RqK~29(vLl@X)lwG zY662lrpGePhk+9R>}C?@^PKnfsa-ErSEn(mf`vu_qh4b@r%Dv}WQgw)({5q5%4?ka zON8QAqT}#E%5%N#YUT9NMOpz{39!Nve=K$E`&b3E^P(bt}%2Ug7F zhpaN^O?J~Wkbe`c$oEyI1jv*JW0@U6U8kNk0Ur&316cx0&(B55dYT`u;=$`rugxlL zBdEn;ibXplf|ln~X|`Bsz5Q|>Ck1Yu{DD;Lm!My=zA_F!{PB;{WD|y8e#sPUMUGnl z);Is~5Bl@v8{z))60has_Y$Fo_RD7lRC*t#>|3MXPyW5kqer7<#uWEG_4Mdmw)_t8LIDvOWrLy#VpfBUx>98J%mx-B5!z64nUVCFtkI8_R%CIl*H zo*kbrC(M4W2d|XLpRE$ce374TO#brt|ZlqT)( zRpe=93B_uy;BUOl0v^MbIpTk}RGC`OyJl07-#fcY)sJCb1(e!OsN+FBJf+w1m#;73 z{1mH9w`;Am+uQJ@Rkx?hGN+|K_*71!_`a@th~qxkxh)_!s==PJbKIYk-e=9f2UM{;di%JodS5n0l|Fvm9jDwg=BbhFDWeg!?)yB zhwN3!M+zDGX`VK~niWeSIK#bm{GQkAb(fOqH`o&Gr=+II;xBx7mI4S5M!oDbXb`@l z_ZroMKVU(ze-JlWCX@qj53Wn^*EVfN@#RCB6;wS<6t8>N{+wlwj8*8{wBPjhWDMPY`sZgNIzX7$FDyI|0UrO z1TRcY)vqukZ`$1CI^>7Z3eK7$C42q<+~heB?P@Mq6F~GM^LsMTrt3%&9rA3N)v6%T z?TE@$!w8(`O+j?3B+vtK6CEE^50N|?2CMYN!+tbVW)Xs^Wy*-}*(|ih1w_4n4C7-H zzKE~kAAblRe*d4e|K-QO{Sq#ZAGGoRDAk&e9~E%S(uXTPNz2#n@gaPaIr-sz{JH$z z0`9_J{~CT?zJCAlq!qKLpMMHJ{(H<)xARI@`^SI$$Jj@5ziB_pWdU{X-@gy;=l?H! z`sor*mp(i$!OdZrwH^8=jh3mXL0TWB`Yp3a=+rXSFXg0R@+l;XhV=6S8>4bIKD>_x z^3u}pQ~zZvVA<%rS{-y1l4DD>QCB?+=G&G4sO}?HeHH)5QTlZr6x_-_6V12HMhC$( zC1Yo=$VR4MQZC+(YdC=@u ze*0}YQ>Ds>>%csMCIhILYtP+_{tN;yY|0+vpV*F4w=0tZ;7+~@tA{Jh=`+l`@$?(O zdjog7z;2J@&y%WD+V+PA=yJ^2Uq8c!rpcRIDGTPov`^_ zXT!7~f8cmS+!CFVf7c%-N&F|?)o#U^Gq+6b;5pUQ-KHYS6|}DFcC(ELo>&5z0|U@r zJ$PpzBmiR=8)I?p%eqUz6vc+DGIfZFhs(7}Jwjfz20ljmzD;h=(LnfOsx}oZPt7jT zh}Y!ExNAxa6*0CDX{tPP{dE6q?`uK@)tDWElL{-%>dgl~xSD+AYU_z>OrXLC?RZ8C z>>!dszGmS*CZUaBfRJB9*B?D!o=aYCebfJIy>@Owr@lT_6Lfp1Qg7!Rq`*(|%WV$l z|LOPP@K65~!n+UQk3W7|?r8!0|NPI|A2UQYdc)@WL0U9C;g@B2uGK5p)nxK%0|Jm7c@;Bm0aRV80pVBr?NZ}hbJ>|lD`YTMuBedc%^u)*>H%;U?~$CWk)6#VS4 zNqGrmye8W&_zf1DFCPpZ-0ay9thA6hqbcGVOTfEC*X%3+TIWktR+UV51ToXAJ$?Rr zrOIHbp*&Uj!l)Z}TdhJEvR3LQQu3r1&SxZbO#4ZD^Ntpvc4F)+mIXqSnM0~t^vmyv zm))fqmVbxvbpdIuRCLHtGsxBH?&ruz;Zr!*wEmaJJK38i%Cv;{V`w%w%kR`vv zQgt}?7Hnyqdat9|B=kd;{NT01-*3kzf%VKAu#FTJrq@;QK!Xs4fuPFhYCeOz(%z<( z?r1=7HbH^F-fAWa0fk+^SL{_eH;1efrSaM9h78XSsC3TtG8fF$T8^m&JUlOR;Lq2W z@Ta;D|Nin64wvWf`)@yl+qdt-pa1<+_`~0RR0_~vK79^<{q!j`U%!SQf(4gPU&8sv zbGY{R@Z*m^hL_t_!Jnu_PNzfo`TaTk%flg@KQ3VF@j*e$^~=}rm+>CH9-8pqm%sV$ zmmk9){^1|OxBvV979P*XAmR9Meb(3i=EL_PoQ@GRfAe0cm(y}BpML%&e15)$@qhkf z_{;J-Kb-6E`96jJ>%aa#8pQnm_rH%Sv|oP?*QcKr(0K`eSP;;1RpI|<@6DPcORh6P zzgt8A$c0rUvD9ko88cC)|Nl4oK@XaTY16!MTGJ#|OjcE90%gSyE;#kwWgP>etkj7@ZKFPShi;6?o!I1*dk;D( zDC*5?v*X`@>n<2d|ckD?su#vT=~LmRS%Z4mrk_H|fxM#08RCbmkNWPnH^>qOd_cLqIW)=LC=pJ4ZdHfoCxI(NRa zQ|%OzBIIjT3C|6y;p$8OwEO(4d$7)XkO29&O#B^>hwdGub-5A+Qmwvct#2%h(PsDq z;67XBvEL;RP;bKh!-C?)Lj2-daDhU}!}IqQpFfVJ&kQPRtm?%u7O(au(!dO3x(5yQ z)lPIApJG7j6G&V$s&KxVI1`74eFAG@LM(d?=p_OP?dljO0hmbHWuJ|ytDV$6r~`j5k*NS1k%^}d8$9o@!9vr`7u z&FVI0D};h8avO`{$iv4p4-TuDu7|QirX38~!4?D%n3F?FzT)OtgLHeJK&+K~>Pihi)Rs&u+ zxACer8`Ba);~}jl|MqYH7P|lOKf?JXCjGZ2@##K(4FB>k{}TS||MB0#?|=V$P2^+^ zI8O<_`~5%um+;U3{LiW`DI7fUA^iUP@54MyYUlEYKl~vKO;T<9)BpFs^gaLdPyZBt z_q*SPfBn~g4gd2${zH%d6q8En=>7RGpA?nw+i$*4Qr}`N5P!al=OX9x?RVdWZ@>Lk z&-dT|{olivn0Ue~OYZ3pKm4G7`(`?a_Qy}*N#Jks@9DXb;*nY`Y@MIYJI**)Y<0k* zDqCwk`vk5ScWh#h;vy10By#Aas6Ei49XyXV&~f;1*c3Tg(8WHpm(HaAd&$KEE;O7k zNp1Kr_KM;VI}BYbn$ewFsi`^g zzAC}%;pts?czn=8&t>ScZw$#LD_!x43*mN5O1Bf*BeOavVVtO9YF16r1dD1&9_-a0KfceO%W(y+ zho8SkoybqbNle5=vVN(}mvu8`9R-TWQ*h*2%j*$4peO@T7T7%rQUh_4 zu8;F%V*-VUb%*4-hjM!RdQ0x|qM-@KyyvrVVAN1W#&^khQq{V6{P)HQAh0cf?;auv zLFcN5-OdYPQ!d(UAjyhG;MZY6kuO=euz6u}1N-cip_oU=3)nc`3b+V3W^B^wI|+pi z#k}lbUA&3-fZ8v}eb*MSPfqB3Wsnm?pU^Q^!$aGWr_5tM26yw2yl@4Jg9Q9HS5NV5 z65nwt&Yc%6j2|Sz^2Hu7a@=PVwD2<5_&k`zW8w9cShfma!HZg#laCJ=#mN!!IVtzS z2yf!~d}A{6c#DbXw{dkcx6c9LCAaf+x%+d1kg*d&muf5Ii>yaM*SMa`?H5O$vjj!%>6()hrP(7n`*l zds$WW#VW;zv@sszWu4a6s+sXV2rN^cF^C3^h zk;0e|FF{}6;6SkmJREP=SKIS^YnsA-AtxJ1lELAV&j%`?od|+xYN=A~?N)_R3b*8W zxrLvum+*%_{xQr=T5H~2I9#q_`hRZ9wUcM^Y<^Gw_5b{DcKkW~&p-aZp+BY~ z&vgDN{NYnf;$GVD=}-R|e)=4ful}IHqV!BI@xK1w|Lgw>|M-vp82ZogRR8cC{`L3& zJsjUX>U^Bzy7!0Q{}}%G?VnNrW`XA4efyoNU`i)j#>1a~_)mqDijSe(%inzX7=HWx zH+qgAu7~gvll?E3K72Soho`S|cy}DayV35MBu`@bAmcIqUJDZ<4IadE^caqDPK2o` zED9h1lkdHC+E!K>rUd5yeQY_-+5ziEc_1cXe6{1;;gA4D{@U_8pY?Yk^Rp{{AGMOf^m?BB>f zcsU6=wc$&+s$ZZ8ru@|1jLY{F{{FY$g{SA#;b_;Ju62iaJ3qu>|6eX$c=s``opFt5 zN3p|@vHlRpRy@bEB`;#wz9i8m;Tr1sxQ?8twt^4km3rkTx+`qU3nkTzumb zInU|hm7QHp(}WJCBUOIWR4RlOMjOJXWejyRJwUePICiP1Z^_-^Lge zuQ^U&yiY9i-2C%N$=6sQIed{q5-WHP%DtA)$_ld~XoBTU?74_=rTqZnPg&f{AeORj z$?raW`lP=Tzd2dsU}FV~1I#7q_90ngzFuK*758RAQ{Wz;h%CpH?|1K>^m8D73sEd| z4L`^ASc}7C6;#uoXhZjw&AlaebuQ0q9w0S-U9Ce`gGS=_GBG&l?E6hdT_@deECNQ~ zVX47K?{NwkMu;j2I$t%?Fd&8A*pmZuoNEo9hlR>leQHnxujZ7Gx$d8ZuWa43qwt(R z=67+Is0zoS#F3BfC6S?)#mZ2%F;U|yG8EQ(?QM|RX;%>7K!vZV#+&0!%?q0_=H2`C z;8^&(hbH28+_~kz2e6GB`2^Jzy=qd{7^i9_(5~SKLu=g}7K14%rgE2Th+3v@V(;v} z&WGauW_36-9EQ(MXq&2>b+gn}Vp%@h`ya8*24FqDc!4BdV40jK!3rVI@n+8IVGOUi zOxGB&iK+F61j{sD6vngoXQ_$r!^t|CsT)$v6M;J#Cy(XlS%O|Vcb;UQlXyMfw%~sG z;s*-`)ga#k1UKlL-`@lN*_aAx-0j<#*f%1mvPkgUzY0x~fCGWaPe1*nLr2HmF;#;9 z<3Ii*1?K4JLU_lx9p4S#gzd5d<9 z7YI60g16aROogCEhc2HyLn}7$-r)oP8ZX^<2IuQbsUBN+6*gP4Nkuix4Si0hjyHvP z&!_MbkNIVMiDPex&+uL7+M~kHu|DaV1*D3@W%<1V`;zAgXXMNpc5p@BBhWcv^*|(g zTBHj}NaEOT$c>W5P_t5S9h^1TeVU2_WGa@nDz-GC2!*0(UlxBkfnbpihSTxB%wyTV z-xpJTyupPWbZvY=(C<^e_{~CO{<(3H3CN(D*b4S%Z#~3D-?f;fDG(u-96NX=Umt^c zL722ZwmZ}dU!UJoYkWWt`R6qjir&yKV0#&P&e!WD$8KEI#j(M8#Qo<&hkVH~M!o>w*B^^o!vrW!ocLj`tt^``VTC1Bp2_rlT+2P(4`&>^Vh z#K9*&UM=&r`^!nISH{Ff=V5`KJK;q~c=2P{W=)d42Dz+lTs|SKCHS0R;rtLh)a0RI z+F4U+!!_P+m!dn%(AU~$bEj9n1h!N{Wg4w#K?PHUNYXRg%-*pe`^3#}F6e@?+La&U zheQ8r@uMWmH>MuDC=p!}Tj|`2^4+m(^;?f75H9FSOmq6at?Cms$6!g2FvA?jw1}&m z9?Q!8n&4jtRIZ_R);2qck#-FFJ$#z~?t>EqZ>$9BIkMcvdyLPg7&lE@_^}<|_qhR* zem2E%vj^UqAOz-ZVK=o|YPW$MtGV=HQ(ss!Q@Ml%VYr z*TI+|hp!gITXH8IT%K!x3aNl`=!bBYPnc7pb%}xYb3C@FSPFde`0a;qj>(4j)?J%L zxmIg)2v3&{0<9g2TT;zL(Lg%O3fqk1?;6kT5)(TuY{)tt@7+rr^XK*u{;rF`jVQ;- z3}_cJcb{~PKkH;jzv^TTXq2CXhCEz}$1q@VI*v%?l8ZMr|4rY8xkqUj=dl{7;&Y@k zn7V}~0wM5t8Rvj%<$<4IxQZ5?wyuXJCBuRCgmp9hcKc>+|K!e--<$PkKNRbyzlU5b zh1XZ1wk)XBm}ou7va<@xK;XxXA}pmWw_M`L6)1L-6bA)n+{f2Eo<-P4q66v1$8}u1 z4dXq!wh692AJRBzl~cXVx7phjENua`t0ibyPq=G_WT>X5>}eyf(LubLvhRHP7{dSi zm!6-elKA&C=ZuSztgg*_9?#WukD9yuHqYg(c?F`g_?pOGt$0{7KKFDQMv9<8kdY~F z|MC2IUvT5N!z0OnKEdCZr;5+wt|ZQb(Pw;5)BDnVm-uL+;w=*Hc}|6{rt8ZXyK9Sa zx`a|~J2c_07xCNITXMI!tl{h-zH$K#<`OAw^p+O(E* z*UNSf<=)8WtIyzd*Lg_J80k5QPowA4@csjMx{g)0E3rfi9J|&B&-Q#)XJz8Qu)kIJ zLE?<7<$)X%2ICThhzP@cwsTG}ROwWm;{P56p4>jh^Dgamq_YVtk2HVxC<PR-*S}GjEZ5<#4$+{_thDsMFy?@oN zEpr{^KI!YO<$d?Qw%*X1#~;?PT2jXQq3_%k`&<)tf@{9>#DZR2w5`D~J@UpsH_tOf z;R1;_+a96&!^LavDB01rF06ff1d`w1_!*tgm*V>T^Yel=4DV0l^RO!-ase6dLpN&^ zBnjrTcibtV)?$m=Jq4%m*$Oaxt*lePO053A;9fJ@EM3o9z*1#RRUxZ*zH%*JzI@jC z^zd-V`yBYdMXa{YuO@Q$RJ`AkyEjOtb`m_++53LgDoTIt=WG+Jaho+>>G9<1<&ISM`*%+{ zf#l7IgJbrK@em2WVfhV;`2l?IanCkOg1S+Bt-9u6WgEoeN?g43e!x;{q8U)Es#VmP zFPM$NX-sb>?@hJfk$vdQD3&2d{2XdNJ$(J(EHI~ypQj{U=WYzwI1gTyxJfU!@Yt?e zkyeh@AqF9*gPOGu!$UaUY+ek>21ESE*n=wv6;gGVjeaRjo`YE_h!B7#>2Y(r=ab}x zg1~oRWmDd~3sp=@?yl!c8C>;4PDW&-6Dx#te{9na=8p-|{u&eMnA{!LRH>a?yPjoA z=HKhQH?BrU%o1_mIp?qIB|YCk?ILWBFtk!7_?uF+BWD=#KLyeQX?pw2nV@2vY!rb{ zJ|@PqjLTUow@YtgnR1zZJg+__knvx;-F zSm2-vUC{HpQ<#RdPFyc9+A)4VC!XsPZ^trp;ZK*pgyovX$91qG(wu_(Z_aT}#K8X6 zj^+tyx2Kh7C2FJbJr_x=Y~7FNt@7XYoRghh9~0UKh3pPGMibXCDEux4P?F;XQ}>Je zhpLHAwr)Q5nwT*hRtbzt78!ZKwf8JC@pg(@q8IpU1XQ`PeP_--XG2HUTh!K z;LSS6CZIFhdbb{Jo!3tNVnYdH3$lJ4!@7hF7j9eY8lY3N>_w*#P=arD&wLxa^G)Po zErg?Tm)t2LGsJOTx98GHH+ene1g?u~Pb(gU(l?eLHYRTIwHJA!vNp$Y@gQrRR5XT| z)}H2Y7!%h|1yyFOGuAQ5{Ia#+Hs4c=L=wuuH-dNNj#li6_*#9kxGQ|N&0X{p-z(;c z`B>)H&>DP!lMBf{W@8~3Hc3a3oneD0&T%5bdzkP1auS67t=6%7jjF)ov2FL>dCbYf z`J$k@nSclL(d~E7p6{W=59mN65#!=J;)8ph!%S-d_m9QnJfdgQT(}kf#EkygluG*? zU*wplZ8E=6pUKet)v@+la`*PNn-De3ey&tBZ8doRC8=75Ev3z(%YmX!oNl<=ovY#8 zYe}XTz2Jb9yLCGmYFl(!h=ku?>uUM?(sf%m2NTtMVfiGNlbvPVC#}56c&?aF4q5F> z0%o5a);g~q!sL@tKJQwWm#dOk%zP4$FDOg-v9opl_C7iOnR(7v!5s-rwbNX~@N=NO z@vN3&!7Y^V=((YT!78AsbJA8JDfo$MDvvW>@F&6CO9B&v;Mok1TN88$l$?7=?AqA| z+8&DMg$;4CIo1xPPf)O82*Yh&OYD47k7S+I$hat!{~nqmxvdEcumF+RI;5botWu|d zZdJ$iPOpD0#$b2oN+_hkAQ!i>HV%@9VEokd8&3;77}>a`vm}Z5bx&w7e6*U@EE<5Pu5M>Z_)My)r}yv6WX%=QY6XGfUM*vJZobe3B~3Fq_q?puI9rOfUdT** zy@e?zH;<2lLXuZf!EG#IP3O8FBRn5C`Kj&Geov`c382f$)CY{MuV2p=AR8CB>uo=@ zb!#T2$z@Wh_i1f6s9P{7Jt>st#3?4X2Q_K$6jq}KDOWh zyfznnu{G@}C7;W8P-`lbzPNn10OS&?TJnlLg`YDx;c_j)72|6M3>6T;XuAGDif)cPqxyO;$xOW_s*Sd0C-SVn`d`yNeaJLDto_oB7bo^!qS>%Ag zLk@O}X46)&?!4$Tl+%A9q4Zv2zG~@tk-T``!@##Lx!{G76XScLJRTNXGm?d1Ljfgp zNi{2RdXD7K9d@1Jb!{@|F5SOIVG^Kbr69UBNXTtxCd>C6a>m@<<>xIvcK1wL)3Fxg z+6^jmo;H}-1o>ie-U{nPx_5B{5}ET;++5=?S|Oq|x9}3LQS~Pqc&a z=t6kxO-a-`;;opK$7@sWmL`=4$LX?pJ8ADkIc~MY!FM~o*)Io!cplu*mM)C^?%l&< z(Mi8uuK9lIhW*}>yE&c1(3$G(I)&3@K}eg@MM-#%W*yP4DR4*d4@hfGxThhDgB9lw z6~ja7++?3KC>)wp{%nFY_e70GFQsmf%hoz`v++3!nS7cnEs{&Iwg_fo9uuSvmLD-# zUgTOj;Ze5XQJ#k=>`E7JYQm=&EXx=b?rDEG64lT6W@dHKHKp1sp2_zw=Qs&(8dMxx zD`=c=1%&+F*l0lBeHC8ZRwNMk@Z3GAr(@UKF|EV8#`BWIwYSQ;s6CD*o{@rm@l?s-0XXn&2;pwI8im-M@}JcbqzWN&GvO`)?*oI4Hf#HTYPzK;maoDL~T zKHGCWV83d*-8p(#<2~3Rif_D+VBXBs_4b8AE*=QaZjr9L1h138fRoo`yQt(%xHY4$ zGgtAsQ#*(;{22fKr!a(XTj5wX;sB8oU=~OLw6o}#(fDS;tJffE9!`hnieTOExr|uy zQvCc{Uj+8Ta<#p|z7)vdlq8U8xFpbT>! zy`Y%?DamooHVgYL3do=b>?t(!E(zuHKzxzaRpT|nl12VoELj-3&Cf+X3&|b2fK0cM z*8hR+-CL6PmfZbfQs;xZnyGfJYgZ%s z;`fh_PZ@HT62U%KCUi0BheE`JZ40gyzDnaZ-lkm(`FpO;05ZUnmb-RXcuMug%_x?; z4lDw}$)0dN0P*0?7At}>Cl8AT&Pghr_h2RPVX2Xha}eFNh1wriAU&s`2AS}Xl$!UQ z=icG@DXfj2QB9}?GQk{laOajKlbH*~NrO)ebJbhM=&}~oWUfl0+K0uPIf5u6ND|00 z&i-0}yZ04cd|ubgufj4p5v}zG+vni^&n&RZNpTU-N~#dH=1x zB;aFn!}#l+r_lBCToeY_P*r`z%oc>x^^3O4n5iERqSg zOFC@+eH#OvF(%wg*wkW2yH5xV)qW%-@dODvQZkZ)A<;{eIfj5qQ`Ab4%NLep-PF%( z(>gCj7ES)+d_F0!u+!()gfa6-^}S8%aKV!fYQa71QtaGyOxgY4@yF4bjer0Am%kKZ z4d|G+){X7h_`LFr+hyFTp>k(f#6)TVj-`DW? zkUX;zWca1<&TPr5zz4YC6u*YB>4qkAtAj0w$(WYu*h*JZuSS@V2s zhSuYnS&g{{L98WVJf6e~$s>dA!Q?zA)N=%D2p10(^j|D8fJ)=MfJWLn5exxP#-SZM*@wRd#R{ac&|nat|KgKm1kk z{M*-Ca;I4Mp^p>)GODkVRN5p?ZG_VhH{Mh^Y_%Gf)YiggCfX#J2q_v@Ht%i1bA<<+ z12&KI*O%-yf(eo~`>k>W=$1?>Zwe|>+Kg|XNdDRE@|IvGNxGhnA&ZkNasunKiWPSsb@MdX#q;ymoiZn@IB}rP zRtJCyu=G0?Bj#B7Zk0Uu{oej~sO2@oD99!Na&rd49 zY2h6*L}Y^iUbV9(&=bE&3vA+iPF*#ISz;_8py9F19(@_2+m6{(nHP6#20C|Q;Cj7H zyQ*IvpVDiK=Qy9^>)IupZer>yf)A(g?eGxZ_m}V(lfFTcRpBhP$zM^<b_#$Vy)pG+bvu1gFCLs2>E%76W?oC)*Ufl4_;EKF4VcAD-T&;O?3% zPu@K~<>HKde>D?a<@Lls@bGZjV9auEFD4~_N%Qq(H0bJh3145nhL`E6q8o=k!SF__ zq#x#9eZg+a-n3bsg(!|TCNqt0T-OgJXHM3X>q{|ay|Ui%;h^(TgAQ?#pTm|s%J=Dz zW&6Qp%L<#SMw%3L=QtLnMVmX(@-4}i1qkglYj1Kjm|&BvYNJ-ngA^KdHWvQ&mS5dKNdyGh*VFJoGFrEajAnYgTl zpQkh*ZZR-dZ}qV1xwgVtil2XOZt*^T4ei+K?>UJa7F#!^d#(G)r1IZ*jW{1j3;G~@ zQ|U6xJ)Ra7=t!!uOXy{2h>py(+LE*Rw$}AmcA&YI+8rn)sa;wiXTzxXR@M;tZ&_z`oF2?H+4jkI$ETubwypIj%!OC2jwDIP`ppGQ zB=wwNU`}H`YZv4uew0Iac}nN`;XDZ#CA>T&+l25n6;Hk&lUey9DAR}d-#?tfyEV@3 zFQ4Oci~;P2_}ZAvyi#zT?MmyP3W8`)t_$=TE{nbTL}cKXUL za}-daOs{Y58nyHM+g1GS_bTU19d(!n<24fC;cu+G=waRX+{0i2!I+-66n#!wDZceHoNuG=u=sATnxPwiPRFCDv1y0aVA0kw5;aYM^c@8X$uMzJ zWz-IksBM}R!%CdXP~pPq=SjDA4#~t^u38Hl-3|%{3I68P6wfudu`XUp40&!SP}gg} zO}lPCuLY=1gJ0s&8&Vvp`C{?>7!^775e zE^IT+8TP3*5+rz%@R8DfhGnR&+mZn3UY-|kgFo$nfVR)CzSp=y$) zLbJ1h;qi#|!+WS^K2w)EeF7U*=vq5ve$w?ihvC}ldM2uvx?j#0EnL35#I?epX{l2_ zYX1DZJlmR=68k2O&rV_3Shp>4Y1aZ3;X7d1w^)F~ci&{~lt9|6N^_Ub^XS+jLGP7W ziD3V&?FB&cVC_d@tVz1tQ#l6lHVi(7;rImH=gzE0Fg{t;+ViEoodfo$+Py#l)YC5H zS+V*qcLt$u>EV)m{@w?V&j;th-9?7~-AD<7))el2t-w&BMNif-c7u ztfVPPCz4-C zAT(EB2;%9vYV1R|8B~`G?xujYUuc>0<~xR*1WIz}1ub|n$D+%@fM4W!GvE0jx%=t) z9W0gY71?}(!FYPyKZYpQo)^PCd}WV+*0`2XqpB&4;ivb%ZveF8@JDK!)Crp?%v7kck>?V40vLpzS@^k=M6zxwcGspX9r0vg|QBghh2fM#@XR9TB-$?3UD2LzOIwE zu~_?BS~pVX|4T+T++qMf+xayROOf&04KaC0=b7yPHXl5BHXiQE9+e91LW1vLyq%0m ztGFX+XCW>g*Pf3InC-+}JmOkz11*gu@v6)sFLEBTm&xacO~n>LvCioMdriFV7_PL< z#&^?>vVG?HI`5Dfybtgm!yW3pKh3TaN!_cW`{?$^+}Sz}CVsLyKHgPDRl*d?_Il5KV<9l+1Y#Y(m;B>C zUroWuj#z^)#3_o6HzNFc>cS$nX1_q-J=V66cUb?49j~>z5vn0et=|Iir3iF z(A`8gQ9r9qir?5@Q6$Egl>5(A5L_>FTyajC2sdHZC1kE7ckS-ctlpBlx36Es?)v0q z2kmsN^xAP2@>K$zg(o6c8aZ&sLLr_?KKNt>I)O@YvgS=cy=V&KsIf5mP24ZeychwR z!hvdyWRG)1pv#L5FML>dc=4-sIk~D1xB;rC3@c%76hm1(+|gG8?-B0ry#@=8w<4%j z{+YAkVUNe-P$Zh11R%NQgpW!6;Pm+ptv3|)>Y-&a+TRHV}L_>^OPc%LAZW;PpaJ;1SU798oA120ehCh%=ZZZFA-LKDBX-H__& zNL(&C+05#WMKIM=&MV|#-_JjP9hf8N&M)*Dxo_Wm^G(qy_Uq{5aIA7cy^p5nrTS-{ z6Nskt{A{gqpF86u8Ls#Db}8iA)yGX>wNvWAA=%E!Cqza2J_p7`MlZl>|;i zSJwC(I^)_&Cr`V0)-hytI!%h@@09RWyS_Glj>d%xJnr~ww#0r}H!B1{@1-lSn$^nG zWM9M7>D(v;F%=QL$YKxJkR=aAQO7IcX8%D~w8>-Sa^3~ejA~)7Q%zBLMnXCz*!Sby zZpx>9Jl5Wf@O@# z!8r3s1YW1G?lWhKlVYrg-pdx}Jg!TTL~!iH&jU#k<`(wF2Zs#eMB1;lwK$9|pnNeB z*TS79zaDe^P($eWb%DE@@>9A`_&dh}+z{~VMBn$jjw>Ukd=aS-;Ir%WT|VYV`gPLp z&75q5hsWM_nd>cLM#Q;ie?6vcfS)Y)LVlw2hxien3r{|IpBA%jw;ccE7{xeuc@J&Y zyWP2(x9;25TXI*;_`OuW57ukukhOtU@?REL6>?RXZeLBR$=UPY`13q;p_UZYJY&4c ztq+W`2yhnyoe5OCys~HJwb1doJLMN~-_Hwoldz>9!@#!#-eY)YmMP@P^%n?-N<@VmJY1PO3mb0ORG3 z3XUUHOFuqeOZa!ZOJ{Wg4?B!m%oPvy$pS!aN*dZ5lDjlc;!_KkQFvq@LNiYprgyug z=Y6`YY9FzjjzvX22f&tWwGw&5vX7bs0s_lK;)Vo3 z#!1}ZSrFhZO2Q1e*Orp!*3=^_Ds(zt`i&>G^h*IjyixHDzC&=f}yJydID~FO*{)Lzu*)YKfu@2dG`Zb1qQ|9%if3 zw_4B`!eboQL%$(kG?j61z{xn%?>|1|fRyJkiyYO8h^$1+T`oV@v48No$LshqZ)W5u z-ln3Atk;Z%mEwWygo& zM3~oc-p5nn>rfPPya)!?G8PhJ^uc<&R;`DykMUl?9aZml#)+dB->A`OSk2SJ{&^p` z*Rf^ff-lhX&olX;`uGYEQ=ac0*6C?A9?9Z6!(JE&NidQysJo)rB>eE#RLWU=jbk64 zCjya_*UDaqeUd-hCumZ1#IawlFAB{}`U=0%1Wyt>aPZ`uv8V8L!CP`Po^vkvQ*xII zm3yJO*X+mMlDxO%?$v~-##QrO3*Hz!obH}CQ_V`jW2Sx50YW+BshOANyNEStC(GFT zjonE%tD|+$<&af6HLL(61WTj>f z&&q>7sORcv4KBi*57|6CyoW2lU%!6d1sgo>uGUfUg!sHjT99zB5a9jl_`E$gloM!l zLuA3{%03qj^w{gRiLe2?|NL6el#;8jcHNWR-#G=hir1QRg>M|?^)c8UZLSUJ^^eD4 zSDfL>GPnRtsxKh1(^?JM{FwF6Ihz5u-ELlc8F}An;$&kuq|Z272k_b(C-HjGO>>T$ z@WAE5xsJCKpv&`>IZ0z!E4R`;wD&K<3o|~} zK@t*^_Ft*E(l}qczVBbE#X1B@#B~hCK)I3GoX?v z=~Gh7Ov#v9Jy^0;z;7wo7V#H4J684zfH05r>d9R`wz6CkP~&JAPLU zx$mlqvmR2%K46T#h&MNNRJzmw>qqXO1vNJp$mJ}mqCzBXrufWAxmfQR65~yTOW|xc z5y9z_xYUZo3qgA72zJe3S71g^E$0i!9d|TYYz=CwEJDUfl@FGSLW%9qoUrGj$5O&Q z8Dh!ZD^@1w#IIH;^~oKt$=s>q{i}vJVw)J=2WzwpB#&MV({ty!8^`;pPqke9 zcpWEqzEB3A-+b;(*;tv^5;3%fb+?ziC3J7e-CxbQ^Bo;eT=fvZ+5*J#-tZwS2J0P< z5=>T9YIt%ouGvEwefNzeay{I!M(FjDybR0p-Av{b`h}fgp*}G75Ktr!zJiVoiaBE5 z1ikBq9j1O~wCp%*oX{aT^iT#SMstVMzqaO)=xrw$F3Zo4J1+b;zR!T~@J7dD6^W|% z^6|DAHC|D=H~sFKdRbzj+C=CMflSO~@^S~c+@4w$iljJFsxjEz?FXR;*mK{Q)U zaOG0&Ba%W8yE(Wk3k`iShXCVZ0T%D$$ictA|NMM;9MzJ(^m&$qhBVGEmgKhM7F^6? z_}XlpEDgA0Fd5o|28My}tMTL(K%$(Y?apl10?OV3dtOHtI~Ed478S_c+1pqqzZQ6_ zY4*dzu9K9LP7-}7IIbZXfos-Sk+$a|ir(`>X}NKrLWKPN^YhngVu|BDK0e&F!|_2T z^H;KXQ?nMqvA{A5&h+TI7p|HPmE4@%No_+CLc8zMQB@;rgU?ClPPkT@{8`sEP?x>d zfj@Mc=nAi+%DH=asanzG;*A`OpsFfjO7{euyNwrFCIza8tn;$T@Y0q#h`C5<1q6u8 zO#P&ZOX6iU`=X^KotNhgmd@Q9tfQQi`)BWAf1F(4??_6#6n-wShOP+8@%|~pC+&HJ z)TNu$cTo0C8M{N`D6U)J>I2pMJVHt^mV?1o!MU5eojw3V!#yXP5hQY)mzPUU60qO& zWG~_Ed6+h!uW8Gor1ym7`^8-8%vrYQgoKB?jkV$$o)f+#iD0CQ-v@j_+RtTAtMHvS zz*fD89w%hnePrk-7k4_9I0*I~w_2B??2I|n@5<{v=9(+dTwRh0GfvHpYv) z+ZbDlAcwn;n-AUA5yR)^b6uvQ+KSDv)=A~S3me4YP*-FF*GPkqbudWEDV&giovd(i z3k9dnS7|W@u|YB9Ltj6wI~X;NF%kdF^V+zwiz0-F!!lIN3mN4Ar*r(%)#SJ-V4|BB zE^|s|MKV1`=V9%w17d+VUWfU`a2#|?_+E>k!;CIOC`s?~^QyV8J3J7PFO_bH{OwF#%QbLjejBo9-86OXc zJQX7J+-xj}uu5y|>sb{2%#x$CZ+YeyTe~?S)Ojq&kmoGls@Ql7jrp|d-(A3!_YE>i z&)?@u669IdZC=ZIXVv_%yQH;#l4}!tmNlHO=P*A?SGzUn;iBt|2K_hduG^ddgg|@0 z62S+o>+J;vsunkmD}DM}+A7xS62Ek~%2EInB9M*95z_VizDTEjO{~ zkTr<->TA2>-N~^=InAz>%4J6in}!emE-jq>#-z7P%V@(BHx@8 zV;#i2@b?JM{P}t*iYc6=)P%mc;HppI z{J_1GXUy?cI{&gT#IctA{V#v{i{3XGC-RNLDdH&csr>D4f2;5N!yo>jkWAb=u}F~j zA})Y(H28YyIZeC7nd6yX6TiPDbZ^Ps4ql*@khyMv$^o3O=6RS0S7y-(;z~YylL^Kh zhTkfq8`_=P6Mwc$3M{@p0ffnFO$wI{tC83sk>W}WFREDd5c~oX3V0h=U9dRGgva6s z1tok2)Ec?c=}E(EZGc6SRYD~hVkji;F&6UM?OJSF9zNmKuo$0@&QDRPres)-$tJko z1R9nQHNG4B4YHj8&JPPUC+c_&HWCEf*f<`|+Y8sHiS-(Gd^9iIQG<$Y*Rt-CJ|5p} z!phu@{2Es^UFNk&2xWZu&z9JINm6fCIhHXOH=D;Kq|hJR1UFo)Gdb~w-e#_0>MU)+ z90$n^Wo5Xi=RpW(0e`P?P+57D3qM&+?&YlWiv12Tm(FG&&Pul)5*$Z=N*t%exBNPO z)${qLZ;}ex6vw$hRYMBoA5GmfoD;7tJSK_zhQ^Yv8?yOJ*WWrK$AE!rA+*H3;sk+zVZcV&HpJC-PKk3j!tTRFbUM^f4pmwK_Oxe8;2AO~ zYm=;7B1j|Wi>?X_WoYr()Paze94x)E7Cngcdj#jw9s1k%Y0R4#!uiOP;O|P)a$rBxq2xl)uS;OLq^&0K_24 zNA!?8bn<>Ak@C9V{qA>qJb5qpe0bJ4j>I20zIOMX()bd(ioECH>ESL!*lQcq=KWi8 z_c!>J_s|nzk$f;zk4d;NG4~Za z4k)q6;B!4U#9tpTlt@B&QhCKPEY{pX;?_TNPP{M%7F4e)=)0jReQgOb!x+-SwW*77 zN0QISi?HzL%O=N(pC=yk>$$TfpD#+LK6$AH0{$6uFmW-pHvSzi@|*~##r!3U(Rge> z!)-9ukZ^k$b0itp>v;!(z=ne7!^s|ZG7?N{-}&I+f|F~Wd%4To2?R&Xsyhp+Crd~Y zp9_iq`8;W?+fV7-SL04~VUu8HVm_|p>({S4*bOJQZPORkR4%e$BlIFF9#+cT0iL_H z#M*lbUT?;Uxf#@EfIvkW-!Y6+McgiI35kB5s4}jd7B_0}^8C9PJZSRAK|9a4@m2Nc&CM0VOz7CIoU?C~b8Bgo`VP|5_!d+Yl>mBohTf7V47UN$ingfejs1OU#hqF^UG`IH68X`I%xZWt0~qUgY({ zapnD8kS5%v#M%L&GKr7m9-~NtMgjoP?(r{1yYs`uK6Qv3tCqsf_^L@2zW7W3^o*8$3V6NHTVj18JQo+!A$MCy^stS zC5l8iY!Hvq96g;6@cboTYSHgyS+g2evH1zMZApQ7=LBPNl58rokH^O{*dQn+uHSC} ze#~*Q>0vY6ZQ#v0Ut=ieuNMU1@yWbGUV|`}(}ritsOPUSK%dlyt-GxW-X{f(HC^Lr zY*jk`@a~B-sjW+cpO)O#))q~^r?I#fizRY3e<_}`=#pMu&Q(qub7C@Vb8DmQjJiWh zLQc}!H7~cBi&?ED?~O?7r~7?5U&?iu?rTyF?TWRoY1&<-m)DlXC5PNm=d}m^P0gW9 zSlUqDH?aWVF5t#BK?gily4AQh2J|nI++AJ{oLu<2Cy}`I+SKHf*>vwQ_wsMhm7h|10Ix}SOKvod6FP&SN zLou=ZI;$^Xd{^2-gCuWr(bej8u@m7G9X+=8r15^c+>+1T+FFq_6*>=+AjYvQwYgfC zGW+lmtkV0?BA)Q?<)j8hL@zj#_Yqnd7nXBfD&z`n$ zHxQ&jE>=z7z^lTdXGRPf8Hax5aP0gjK>~#7ukM5elHM5phIw-3AHul^YUG3 zF3fU5hE85mzI<1}BypWw%s@A z*K-l)j$U0t6o4W>`HIwMV5Yqj-5L%!`$ln`puTb-M%gF}`mee4b64ZFPbFR{3 z(edWc*l=YrU|xhz#ISgKTsoei@4R`T6wedmKu{J}RN;O16Pp7hfmxKL9Ai!Pee;-o zz-~D)g+Kt3ZrR|y3MyBp8Aij<*zH`_S1X&G=>Pex`Hr{<8vY<-?FK&f*$T2iV`B)QkC0pnw@FA4?wsh zu;UC;aKnml+!a-r%tMljKJ^xmADV1Mkng+dt#2GO4MJ`qb+r0!_qlv7GOm2bs{y=H zo~Llo&Uqfhl5?`_C?LCX94N9H=SI6zlKN1mOA1G++j)-nF~RRHPv*ymbtZ&Y_ZQ}o z@^?0zHl<32ZF8ZFxwOn9$6kJ03`vsrZ$mgVsRiBM);PBZ5U$ecYHypupjkdN zSbN(hTfz(?q$7?PmfR_nx5s&0HU6+EB z{F-XG-viN^#(v5BCXNqUMh%_7oyA?zp62RnoolFt7Ts1_XP~w%-w;1Sf(Pn}kDEBL zs~M~FoaH@*V>rBCJ_8U-tmROLO?(;N?z`{ux-aJoL=!9tEwxinR)!SHG0Wi1&FDZ6Ao$Ohs#$>Dr?0Z4P*YVmOUg@?>ER;PM%Y$D06S;k}QX zPm(UE;(hJwg z!$$a@3|l)(U1`R@SLKGk~XHN~T_lju>(_`VFQ6QIQu1pG*(%IyoaB*wljbNu79OP~#aYi|D z;m)lW48q)(@pfIxPIj}FYKo%9$`yQuQ#0TB6odY!ho|sPL^%3*uex-@Zt$?p<&+;*&Fwtf%dgq7znOzOGl$NL1h zk={RzP3!e~LuUosbUu#{ttN9roYzOOct~W*yhgD#oZ`>Xd@prL?Z@yS z!Ejvrni(A-Ti2Q;@vWQ39a;s2O;#=D4wUEg`=prFaJisbwfqQcReB%A51fpg!^PC?JvEuhAmdbiVf7c^vxUB*#7|u0qlu{A?sJfDrlwgOM8?b1)B(Q6b)P z1)rb12z$NGy4c>5`D`e>;#^T!W~7n)Ub<=!IJsPIxf98qIj`@4W`vvv+a~E@y9ICCk0m&r+@RC51EIj9N6=VzW(#)pHgRh=yn~u zHvyHm?z~L0$5}Ji%Wsr5ewZJ4+-2d{vyFi74*2SsZ>h6a5GsXUP{j)Xcu8Pi zMfM#(J|~tZu3@)*a#Q0b`6QSLzO{uHK|TA~@oNx#3+Ij%DzWg$Vk3(V?mctUI0*L~ zGT*^r?;k)D7&hUby$=)^?&m$1(tD&D&gb$-T#&@1}DnT@#Ja6u}@@a`F7Vd^p3quD8UwY;UPc^wOkFvkP+>3^kj4 zJR3_7G=FMevk7D5L<^l0T+`C-IE2dIlKBQ0H2KJJlCRGh=GVOLaX?im2z12LYK|v8 zzb>F-m^!wBeCD_#trhBaQ4{A{v2COxQi8#ivg0s}&dPAzRCe;5&m=m(-oG;ke3zGE z>>%;NXFNVU7D{^D?e)gKc^2# z3^53ku2IJ(_x$zs>)k@6ChNz|#J=Wp2b1Ns0=1X(zpj_9s~5^*;+)JbQzG3bS@z4L zLD_5#T$W~+eDHqm#}BWy`kcGA=+yZ&oH9gOfu)&mjEd(H6WHLhaEP#qpU~-)oAVj9l`CZT#E& z;(F^E=`Mk00Z(5R$>Ri()jBsHw`o^=X5@cO6QNd#V&dWoG2q~# zNH1!ca$TUOctv#xzMyM|*Wvtr_~C~<7MQQf0)B!Xl5ZS`mAuD1j~DZ`E7xHkPy4m< zmyFHdlDogbue>3wb^2eme#q4^RFk-pvaV%7j$j&uZeA?eRv`0s zx)OWrg9YYN)h2=OB6>(3UndeOC~z^Hsg|5FWX*TSYWJ=PN@>E^xIbGbv8*t0hmjNW z&T-SQp&(hVbt`!hLs08s7_#_#J_COqS4R1HZng*W&RCokx7;3p`smcLL?K`zoEYMXlakLB_6Ox`vH&XS_Sm&P`sHCQma*b|HUV3!@ul_l9uB$F*O=*ghRexu#cD-6rfuPCxFH8pm*8+~ltX$w z#Dwn_@56G5NxaP8hn>}quA5MG>`&Ek$8*w4-1Az)%FkFgnQFjez!!Gp`|D*ap@eHw zaM=WwDQcP5+jBhcbC|k|Dwr0XC^fN+#}`qlfIWUr77CNyzufsTL+y4A-5QDnmXp#N z6tZS}fzFV(Qp$pJ4))H-Aul?FE+->1JT!gdnx-VBKb>}z0p1S_Z$tMjufhJ}e_zu8 z@bnu088s0sNtSpo@iY_ZWU&%5#+qwyX5oz)r7nTk*o$`m4pMyUBW@n#X`eX z77Z3|(+(cMoeu5}aiD>K{&4JzYOp_FF9PAYWS)=Vg+ye6b47|F9t=mSLDtx3&Wjds zmye+d468%HqbyH$}+hr+aR_nr|4y-+ID$H+y1bvCT+y4GcoE`Qd%7N257fB#* z{|C8Uqmr$D7GcOXGA|R029G$ws7&FqD;VL3F7WfD$ zsT;=1R2}E@;$#}<#5^nRcA+SfIiW-9*qxd*&!76_opcy4>T#v-H7Hlnxzk|2Pw>e- zEFlo|Km+)hI;a_1DoNn`!gEEC3-L4r@q`|}zimoi1*vs=4s8NkGgX4dA zdMJFb@&*f&=r3Q30B;6Y+JePkNosq$=8jE*Gg^`&NsL@0V4rqx*PN)N1ac7iWrPs$uLd&Y%OMd{#@>Z2tHwjFrKYLyodN}=l#hzxdLZg2Zc5E z%chpe1;HdpW9zo9lP4<9d2YH-UTPLG5=`Rt7qji)`&BbBFOz>ezYYqjX|4JBEJ5rV z-Zzi&8H%drNL=L&b~wlNSK`;f{O*`zgaBG#nTMq*BWe81dt|hY7iN>>$}6Gr_=Z}zM_}-J zQL{MV@$ZW<9DjN02t?1k^$ik!_OV4W?7d_0xezB|??r~Ms?X=Ur@U`*XEvi844owZ zmc33oaSSd0^y$aK&y(kx%m-QjygdXguykz3u`JIBYpOhN`3y#{ z%dCIc*;T;Uw;0a{hJmO4$!mHM#Cn>JrfM*Xu+ZeQgW@9;5=C8)CZ8$bjyM;tOkes zD;3LhKjSlv>r2xOR1}e!zv}(FUekTQ9XA8s&tE==^V3P8D(Hk9O?V_`Eqc$9TxH{M zh-LKMmL$dT(ZLu?pT$;CI>{-ZpXz~fJpR94xg$9pH##fupf9g_Dqn!_hBU;jlpi=VLcpbtK8~PY9-kNY7V-g&n zH_#DU(3tK1*yoSe7<9x0V-899r$3zH_}S#o#Z!?xJ2$L-G3Yp+Vvsiug|RXUDT~at zxHo+M`R6=8j>bRKN_!mF^Yhm@P7iSmT}?STRktCu^i{+nL`wW(K8wRC-kU+8*4pVZ zQ4(EeAc_-`0;k>^U3b#nA@Jnf!9&+f{#$}JO(Mw8PM~xOZJxrHn4D=KDIEk^GXy3J z$S1zx-^c5>j^Ry-v1{6rcR2~C^P<<$tSBn=ItL)6qwB+Bwi~N`+x{dfp`ti_h~xG$ z#o+al#_Y>uTC3m3byGQO^O`IMsH2(^0d#E;oKJRHjjhM&nVr8}ilha5IU^uY7~=IX z7na)2g6jm&J+0|EJsci1w;iTrCf2s2VaCqLVV@=27?V-DAGzViUkz&#pUY93mefV?Grg zHf}$}>9FTPbrRzkqAbPu9!w-H?z@6Q`toT@rUmCMoH|ZS@myZwc>na%r|>X5>2@vZ z#b1B^8ZOTl8*^Rw=EKL_#gifyc!ToH-@QA9@4x>(?zazGK$dd{zj2Q1;g6sGtZR2S zl!9UEn8H*daBihI8s3t-x8#mteIZoUB7be0mu2nmdERkrn>!e~V78?xITln*K=#aH zf;0j^#?-Ur0wy6k86Hl9e=}^)L+*Y}f-Hf&OiUz6Aje`cMIzuKf%rxhpDU)`_?;JW zRN9d6^u~GEI7FrD+vdYJRUxPX8Q{bc=Yzk4v&QgLuCPs(7<0v(J8kF~C95tM6Zg_!Lm`};yllF4hY(edAm z4^wuh!G6l==afW>dDt~sButW^b=FZbWx&4MibqqH&`wq1X)S%EHW+7F?ahJ(?N2gle-#dGK=p?^otMf-nd@$?tBG015PNx@~9xSzF8yyy#Nu?dnn@Wr8;Y zlK5>yO3w=Gqg2;Tbu&LpD+b8#p%%QTvgNX?gx9Qe8Wa)a-%v}m!a-i^=cTah$%O}W ze~I&y=n$s`yu9hUU6V4|kv*Y=y@JZR{HNjFC_hh{ACMKx|4UDx&ImwuX7}lDqQ1p4aSD#YB zZxA)jc&yu{RPC*Cws~D=7$p?E_X^5;n4?$1%!y=J3m!OkO_}rMd1v?rM3C2RUc>R6 zJ+vOb!*wwfmA^onV5og*?=u!i64n)9D+Y%6Gw&arMLu^F;Nj`V@tQ||F%1B!*)?%I zPPqB}SWC7SG*kC=1@0A0oL<=!x? zr+9`CVTs9kr=p1nI+hfxcCEq=`8-$@VZ6W!{NUo4zA$UL_gY(Pye!Yf65p3{h z@P@-Y8ioK3L+O9X^O2?W`7@YA-$~ag264v`o_Z+>ALk9eqn(e{0`tz+f%c%^1HmmD z>YSj8Ig`mS{$3QLU~Z1U3qmR`S@V2c1nXYbTh|-vCQcT7v}*88K|a<3dnTiG?%FhX zr4_Y<(1(TipB*@nmva8JUBM3m^aiBE!b59KEmApca}|=?;<$LeSRX8y%ws_UE`yYM<-nS$v=5#) zZ^Dq_xs7pYnNugiLybW{LjjYsWO~`eZkQLHRRjm~@-hpQcEQ@%YQ&6uk!~wG(7e7+-8MHAX{pyK&o5a#@SfU|6+!_4v?8X!GQ)y# zU>#cNhz8l;jytXz!!((P$DJ-;%;Szu6wVC3n9%(fg%;-@TC(40BMoZ7iY6-OCH+ zIv2bh?q;#K8gqGglAy8(EH)+}szgJDlfx5(IbpmQdLDy^PHq_aCUcXx`^e%Wd<_2$ zOukPZ+1S}9JG|Hml!YNF5<>E4ZEBfK37@oQ@w36IaR0m@3_hO|PHZ%ZBi8Rk5g5Xf zaOFexl7UxFErG0U2JE4hd1+RCM5mND4PTu_Wf6zoZN-6`FqjJ-AG^ z=#_gC$KHAg&28&$P3u(fRj?jPQGmTbw>j2Si%Ta9AZiJKpC`ONPEM86s{rPJvPnTP zRP6Blu|{`&vzMp`2QF)7UXsvnBvqNY;q3uoDDQUsk0IkF`kfNQ7o6qvWz)r`}u@Vl|S#W9!GAXQ?$eNuag zW@&b7Ofm=$yF!Dmw~LAiYw_SURY9D;SINZs1(=>MZsGcTSB(W*lCNQxIpCNpK-I8P zaxLa!+aTtta)Fb5UOo4f=UZ*B@%%|HL~V+kOOZ6P2PvCtbD@IcFBUulM-wO+bjsM~ zfb|6UCl?KQjG}nV#Z`_Mu)l4l=1WchuNkMNs`2VJjdGB;VN;@HlVe^)xog1+lBlNms(MR-0K-PT?0x19xQY@7(S9@7 z8>X*CH_3OeY5^7h{@H>LPKdc;1z04*gLp9)6Z1mQr71h6xUYgy=S|yhex8)gul2$& z;4J9po7$Q;hUcn0e+J7uCs@l~*v2Ot_aU(*?8KAl3nOg%_T303grlgyaAHpTWIn zLOv7aH;7ALoSRodJ3-DJO&m2hUxVG`jYfbJX)dymN2m%r)0iB$yalaZu z8-$9W2BiAC&ODzKmMPFg6Ky%2s;CD^?vw-aRCdl+TEmz>oTz;3P7yYtAIo)-*K+Rs z_&_l$H&Swt=Z$rJr`raJQ%=ppW8q~rFJ+fWVTV?*(qu@*Z@O?a_`LEg=OuSryWx

;7c+kSDh;-dN7aq{Nj zg&MDU`JR>sZCpLu7d`gjN9WLtcE&t8_97i}x13zZ@6Jz92cu%;&>aAxvB0n3X%+<2ebhe0|<%IoKad#qKHl@#%5;bRQ*tLHARH zSmdXwpk7~6?AN^|Z*R%n|7N21OaH$2g+=ck)UjIWef9_+){D7(RdQA?itD>iNL zHwTAo*PXXZ4U)qquI$m`7jL#0;Ke*I`VI!k>ZSkQV|@037!OmkF*-z+bxloIF*EC`G}>0&gu0+27j3QImkh zs?At~LKjXh^)599+*^Wj!Gc=3Ox% zCt&g|uZ>C0hyW4m19{3R1XGe=wy}_PZ?^G4)(OF&ncSHHf6`7o@$bNs?E8H(UsI4? zT;jZjqIec4p<)hTo<9WbG zdyR{S_k8);iaWMetZT^Y*q#l=NFN1PAfl1y#D>mY98A&s2K zbC((SnG-v|7U4XBNRem6+5o(t!*rZ~&z;4lYb!Bpn-eZPL*FFW;z8Tn+A@JWoznXy z@l3JQW@InFe|$ag3bbNBZ3mfYRp%GJ!BYi7^CbQ~{% zkI5${uAJP6QdR-&3e8V7@5GTdK zbtxhB-wq`7vTAa7n{0edX>1)&k43=38;pF*=E@Kt&t2rMi67tG#p6wwWz&UocTcXL zy9wUn1Mkt`L;CmgQi$HHHxns(i1&KgI$wGIbjcU2MQ6gDgN*z1mU&x8pcYEi>)g2! z-iWME)LjV`p^V(cw`47IWvDQ~Yg4;LY8xMnMT4yPG!E%Jj|)^k)90sW+2--C#gX9< znrV}TFRg2q!k9R(fn?vo0pqeX)sBsaaQlvS9w&~^ldJvqIuvtIB)Gnu3ok^eU~@Hn zTDz^orB*#-7zKidfDqw~C2bjwNrvWlFOtBO&Y8OuoQO8IZu<2XMG5Z8X_v`$AMU}W zGXKi+wq$N-azL-Qahr>IasG=+Bun8>If=I9v=2MAX!eq1L5|wq&ghrgzQD-?^KfzP zc&>P+*E!wys}ybKct3Al>acYQ0vOs_5hmp1dbXAbb?7{E$YuQ?$ZJ2Vv#c*6JYc-(2j*cFW zi(L4Ub2tn|cMvhd=7V?6=gyRkTCthI=?o#W3{8!@gfo#dvFlFP+epWB*D%B zKHB}hJH)}cSK>n@4Kl-gZk#CiL=gXGSfo#`Q2E(@zZ43Y=s-fjkdIyChON%eishJn z63b9kBp#>ZW5IP>)}?@VAeo-$(%Y|QV#{4n1n=mwL3Pug*Gx&V=O)0y0*gG3!xh!% zirSVZX4m``as9pX_yeqhH%;&D#K*m!Uovli$V(yuLsPhRm*cuC^+$)02Guvf}~<4>7f1 z<+fU27Lz+cv^5q>_Hq1Ws9LLKUsX{=QYQBko`z~cF;7LsJM%BwavjM$A4}SOlJ7eW z-h?>wa4dm?s6wui+xrl#