{"version":3,"sources":["webpack:///../node_modules/physicsjs/dist/physicsjs-full.js"],"names":["root","window","this","module","exports","Transform","getNextSearchDir","document","Physics","world","apply","arguments","util","aabb","minX","minY","maxX","maxY","x","y","hw","hh","undefined","Math","abs","contains","pt","clone","union","aabb1","aabb2","modify","ret","max","min","overlap","min1","min2","max1","max2","ptA","ptB","dir","ABdotB","normSq","dot","ABdotA","negate","vsub","perp","cross","gjk","support","seed","checkOverlapOnly","debugFn","ab","ac","sign","tmp","noOverlap","distance","simplex","simplexLen","scratch","scratchpad","vector","axis","last","lastlast","v1","v2","iterations","push","swap","equals","zero","normalize","shift","splice","done","maxIterationsReached","closest","lambdaB","lambdaA","len","length","prev","A","L","a","b","mult","vadd","values","getClosestPoints","statistics","pushRunningAvg","v","k","m","s","pushRunningVectorAvg","invK","get","add","vect","angle","origin","o","setTranslation","setRotation","prototype","cosA","cos","sinA","sin","t","transform","sqrt","atan2","acos","TWOPI","PI","typedArrays","Float64Array","Vector","_","recalc","set","Object","defineProperties","n","sub","proj","norm","vproj","ang","NaN","angle2","left","right","x1","y1","x2","y2","dist","dx","dy","distSq","ccw","transformInv","rotate","rotateInv","translate","translateInv","component","clamp","minV","maxV","toString","_Physics","noConflict","Decorator","decorator","type","baseProto","registry","proto","extend","to","from","desc","key","getOwnPropertyDescriptor","defineProperty","isFunction","value","getProto","getPrototypeOf","__proto__","object","constructor","objectCreate","create","F","mixin","val","factory","name","parentName","cfg","result","parent","opts","init","indexOf","arr","fr","bk","clearArray","l","pop","throttle","fn","delay","scope","args","call","cb","clearTimeout","setTimeout","defaults","fnTrue","wrapRule","$eq","$in","$and","operations","Scratch","Scratchpad","scratches","numScratches","regIndex","deepCopyFn","isPlainObject","options","def","target","_def","callbacks","deep","i","onChange","pairHash","id1","id2","Function","bind","Array","slice","concat","find","collection","filter","matches","objectTypes","identity","objectClass","nativeKeys","keys","hasOwnProperty","largeArraySize","arrayPool","objectPool","maxPoolSize","keyPrefix","Date","releaseArray","array","getObject","cacheIndexOf","cache","cachePush","typeCache","isObject","index","iterable","idCounter","uniqueId","prefix","shuffle","rand","floor","random","isArray","reNative","RegExp","String","replace","shimIsPlainObject","ctor","baseUniq","isSorted","callback","isLarge","seen","first","mid","createCache","computed","releaseObject","criteria","number","string","valueOf","objProto","test","isNative","uniq","source","guard","argsIndex","argsLength","ownIndex","ownProps","sortedIndex","low","high","_active","_indexArr","maxScratches","maxIndex","join","handle","register","idx","stackname","useFactory","stack","stackIndex","getPriority","_priority_","PubSub","on","topic","priority","listeners","orig","_topics","_bindfn_","_one_","_scope_","off","listn","emit","data","handler","e","event","one","pubsub","active","ps","perf","performance","now","timing","navigationStart","requestAnimationFrame","step","time","ticker","start","stop","listener","isActive","prop","thing","next","toMatch","$ne","$nin","$at","point","body","query","Query","rules","$op","op","rule","list","$or","behavior","applyTo","_targets","getTargets","_world","_bodies","setWorld","disconnect","connect","behave","hidden","treatment","mass","restitution","cof","view","uidGen","self","offset","state","pos","vel","vx","vy","acc","angular","angularVelocity","old","_sleepAngPosMean","_sleepAngPosVariance","_sleepPosMean","_sleepPosVariance","_sleepMeanK","uid","geometry","sleep","dt","asleep","sleepIdleTime","sleepCheck","sleepDisabled","limit","r","kfac","stats","sleepSpeedLimit","asin","sleepVarianceLimit","sleepTimeLimit","accelerate","applyForce","force","p","moi","getGlobalOffset","out","toBodyCoords","toWorldCoords","getCOM","bodies","com","M","_aabb","getFarthestHullPoint","getFarthestCorePoint","margin","regularPolygonVertices","sides","radius","verts","isPolygonConvex","hull","getPolygonMOI","num","denom","isPointInPolygon","getPolygonArea","getPolygonCentroid","nearestPointOnLine","linePt1","linePt2","drag","integrator","integrate","integrateVelocities","integratePositions","meta","metaRefresh","width","height","autoResize","renderer","el","getElementById","container","parentNode","drawMeta","addEventListener","resize","offsetWidth","offsetHeight","render","beforeRender","_interpolateTime","interpolateTime","createView","styles","drawBody","execCallbacks","fns","then","timestep","maxIPF","webworker","World","_meta","fps","ipf","_behaviors","_integrator","_renderer","_paused","_warp","_time","arg","addBehavior","addBody","remove","removeBehavior","removeBody","has","_dt","toPrecision","_maxJump","wakeUpAll","getBehaviors","behaviors","getBodies","findOne","iterate","animDiff","worldDiff","warp","invWarp","animDt","animMaxJump","_animTime","_lastTime","toFixed","pause","unpause","isPaused","destroy","started","_started","dtdt","dtMul","prevDt","dtcorr","children","addChild","g","clear","ch","maxlen","setVertices","vertices","transl","_area","trans","xaxis","yaxis","xmax","xmin","ymax","ymin","mag","addChildren","refreshGeometry","w","h","strength","order","_pos","_maxDist","Infinity","_minDist","position","minDist","maxDist","j","pow","supportFnStack","checkGJK","bodyA","bodyB","inc","d","os","collision","aabbA","dimA","aabbB","dimB","hash","searchDir","tA","tB","vA","tmpv1","vB","tmpv2","useCore","marginA","marginB","getSupportFn","mtv","checkPair","checkCircles","cols","compound","other","oldPos","otherAABB","c","ll","check","channel","checkAll","pair","candidates","targets","collisions","prevContacts","contactList","collidedPreviously","mtvThreshold","bodyExtractDropoff","forceWakeupAboveOverlapThreshold","getUid","clampMTV","totalV","into","_bodyList","respond","collideBodies","normal","mtrans","contact","fixedA","fixedB","impulse","invMoiA","invMoiB","invMassA","invMassB","cor","rA","rB","angVelA","angVelB","vAB","rAproj","rAreg","rBproj","rBreg","vreg","_mtvTotal","ratio","_pushUniq","col","_oldmtvTotal","_acc","setAcceleration","checkEdgeCollide","bounds","dummy","checkGeneral","setAABB","_edges","moveThrottle","minVel","maxVel","getElementOffset","curleft","curtop","offsetParent","offsetLeft","offsetTop","top","bodyData","bodyDataByUID","grab","touchId","touch","touchIndex","changedTouches","identifier","pointerId","pageX","pageY","isGrabbed","move","release","PointerEvent","removeEventListener","_maxDistSq","_minDistSq","calcPotential","posA","posB","normsq","minDistSq","maxDistSq","comp","lll","potential","dof","encounters","tracked","pairs","intervalLists","xyz","trackBody","untrackBody","sweep","broadPhase","updateIntervals","sortIntervalLists","checkOverlaps","hole","bound","boundVal","leftVal","getPair","tr1","tr2","doCreate","id","flag","isX","collisionFlag","z","enclen","tracker","tr","intr","interval","minmax","count","trackedList","_distanceConstraints","_angleConstraints","intg","resolve","drop","distanceConstraint","stiffness","targetLength","cst","targetLengthSq","angleConstraint","bodyC","targetAngle","cstrOrId","constraints","isObj","substr","resolveAngleConstraints","coef","con","corr","invMassSum","resolveDistanceConstraints","proportion","BA","shuffleConstraints","its","getConstraints","distanceConstraints","angleConstraints","halfdtdt","Pi2","newEl","node","content","createElement","innerHTML","colors","metaEl","strokeStyle","lineWidth","fillStyle","angleIndicator","hiddenCanvas","getContext","hiddenCtx","viewport","nodeName","toUpperCase","appendChild","ctx","els","className","insertBefore","_layers","addLayer","layer","manual","follow","scale","zIndex","style","reset","addToStack","removeFromStack","clearRect","save","restore","removeLayer","idOrLayer","removeChild","setStyle","drawCircle","beginPath","arc","closePath","stroke","fill","drawPolygon","vert","moveTo","lineTo","drawRect","rect","drawLine","draw","circle","src","Image","toDataURL","drawImage","thePrefix","tmpdiv","pfx","arrayOfPrefixes","match","px","cssTransform","borderRadius","overflow","pointProperties","marginLeft","marginTop","circleProperties","rectangleProperties","chel","attach","detach","nodeType","par","fontStyles","font","align","fillAlpha","strokeAlpha","alpha","isTransparent","PIXI","color","stage","Stage","autoDetectRenderer","transparent","resolution","devicePixelRatio","Graphics","loadSpriteSheets","assetsToLoad","loader","AssetLoader","load","evt","assetsLoaded","pivot","rotation","setStyles","graphics","beginFill","lineStyle","createCircle","endFill","createRect","createPolygon","createLine","Sprite","fromImage","anchor","chview","cacheAsBitmap","loaded","setText","Text","createDisplay","texture","Texture","tex","frames","fromFrame","MovieClip","centerAnchor"],"mappings":"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","file":"43-b62a1d204b4a6eac2f0d.js","sourcesContent":["/**\n * PhysicsJS v0.7.0 - 2014-12-08\n * A modular, extendable, and easy-to-use physics engine for javascript\n * http://wellcaffeinated.net/PhysicsJS\n *\n * Copyright (c) 2014 Jasper Palfree <jasper@wellcaffeinated.net>\n * Licensed MIT\n */\n\n// ---\n// inside: src/intro.js\n\n(function (root, factory) {\n    if (typeof exports === 'object') {\n        // Node.\n        module.exports = factory.call(root);\n    } else if (typeof define === 'function' && define.amd) {\n        // AMD. Register as an anonymous module.\n        define(function(){ return factory.call(root) });\n    } else {\n        // Browser globals (root is window)\n        root.Physics = factory.call(root);\n    }\n}(typeof window !== 'undefined' ? window : this, function () {\n\n'use strict';\n\nvar window = this;\nvar document = window.document;\n\n/** related to: Physics.world\n * Physics\n *\n * The top-level namespace. All of PhysicsJS is contained in\n * the `Physics` namespace.\n *\n * It may (and should) be invoked as a function to create a world instance. For all intensive purposes, [[Physics]] and [[Physics.world]] are the same thing.\n *\n * See [[new Physics.world]] for config options and function signature.\n *\n * Example:\n *\n * ```javascript\n * Physics( cfg, function( world ) {\n *     // use world\n * }); // -> world\n * ```\n **/\nvar Physics = function Physics(){\n\n    return Physics.world.apply(Physics, arguments);\n};\n\n/**\n * Physics.util\n *\n * Namespace for utility functions.\n **/\nPhysics.util = {};\n\n/**\n * == Special ==\n *\n * This section contains miscellaneous functionality.\n **/\n\n\n// ---\n// inside: src/math/aabb.js\n\n(function(){\n\n    /**\n     * Physics.aabb( minX, minY, maxX, maxY ) -> Object\n     * Physics.aabb( pt1, pt2 ) -> Object\n     * Physics.aabb( width, height[, pt] ) -> Object\n     * - minX (Number): The x coord of the \"top left\" point\n     * - minY (Number): The y coord of the \"top left\" point\n     * - maxX (Number): The x coord of the \"bottom right\" point\n     * - maxY (Number): The y coord of the \"bottom right\" point\n     * - pt1 (Vectorish): The first corner\n     * - pt2 (Vectorish): The opposite corner\n     * - width (Number): The width of the bounding box\n     * - height (Number): The height of the bounding box\n     * - pt (Vectorish): The center point of the bounding box\n     *\n     * Create an Axis Aligned Bounding Box.\n     *\n     * Signature:\n     *\n     * ```javascript\n     * {\n     *     x: Number, // the x coord of the center point\n     *     y: Number, // the y coord of the center point\n     *     hw: Number, // the half-width\n     *     hh: Number, // the half-height\n     * }\n     * ```\n     **/\n    Physics.aabb = function( minX, minY, maxX, maxY ){\n\n        var aabb = { x: 0, y: 0, hw: 0, hh: 0 };\n\n        if ( minX === undefined ){\n            return aabb;\n        }\n\n        if ( minX && minX.x !== undefined ){\n            // we have a point specified as first arg\n            maxX = minY.x;\n            maxY = minY.y;\n            minY = minX.y;\n            minX = minX.x;\n        }\n\n        if ( maxY === undefined && minX !== undefined && minY !== undefined ){\n\n            aabb.hw = minX * 0.5;\n            aabb.hh = minY * 0.5;\n\n            if ( maxX && maxX.x !== undefined ){\n                // we have a point specified as the third arg\n                // so we assume it's the center point\n                aabb.x = maxX.x;\n                aabb.y = maxX.y;\n            }\n\n            return aabb;\n        }\n\n        // here, we should have all the arguments as numbers\n        aabb.hw = Math.abs(maxX - minX) * 0.5;\n        aabb.hh = Math.abs(maxY - minY) * 0.5;\n        aabb.x = (maxX + minX) * 0.5;\n        aabb.y = (maxY + minY) * 0.5;\n\n        return aabb;\n    };\n\n    /**\n     * Physics.aabb.contains( aabb, pt ) -> Boolean\n     * - aabb (Object): The aabb\n     * - pt (Vectorish): The point\n     * + (Boolean): `true` if `pt` is inside `aabb`, `false` otherwise\n     *\n     * Check if a point is inside an aabb.\n     **/\n    Physics.aabb.contains = function contains( aabb, pt ){\n\n        return  (pt.x > (aabb.x - aabb.hw)) &&\n                (pt.x < (aabb.x + aabb.hw)) &&\n                (pt.y > (aabb.y - aabb.hh)) &&\n                (pt.y < (aabb.y + aabb.hh));\n    };\n\n    /**\n     * Physics.aabb.clone( aabb ) -> Object\n     * - aabb (Object): The aabb to clone\n     * + (Object): The clone\n     *\n     * Clone an aabb.\n     **/\n    Physics.aabb.clone = function( aabb ){\n        return {\n            x: aabb.x,\n            y: aabb.y,\n            hw: aabb.hw,\n            hh: aabb.hh\n        };\n    };\n\n    /**\n     * Physics.aabb.union( aabb1, aabb2[, modify] ) -> Object\n     * - aabb1 (Object): The first aabb (returned if modify is `true`)\n     * - aabb2 (Object): The second aabb\n     * + (Object): The union of two aabbs. If modify is `true`, then the first aabb will be modified and returned.\n     *\n     * Get the union of two aabbs.\n     **/\n    Physics.aabb.union = function( aabb1, aabb2, modify ){\n\n        var ret = modify === true ? aabb1 : {}\n            ,maxX = Math.max( aabb1.x + aabb1.hw, aabb2.x + aabb2.hw )\n            ,maxY = Math.max( aabb1.y + aabb1.hh, aabb2.y + aabb2.hh )\n            ,minX = Math.min( aabb1.x - aabb1.hw, aabb2.x - aabb2.hw )\n            ,minY = Math.min( aabb1.y - aabb1.hh, aabb2.y - aabb2.hh )\n            ;\n\n        ret.hw = Math.abs(maxX - minX) * 0.5;\n        ret.hh = Math.abs(maxY - minY) * 0.5;\n        ret.x = (maxX + minX) * 0.5;\n        ret.y = (maxY + minY) * 0.5;\n\n        return ret;\n    };\n\n\n    /**\n     * Physics.aabb.overlap( aabb1, aabb2 ) -> Boolean\n     * - aabb1 (Object): The first aabb\n     * - aabb2 (Object): The second aabb\n     * + (Boolean): `true` if they overlap, `false` otherwise\n     *\n     * Check if two AABBs overlap.\n     **/\n    Physics.aabb.overlap = function( aabb1, aabb2 ){\n\n        var min1 = aabb1.x - aabb1.hw\n            ,min2 = aabb2.x - aabb2.hw\n            ,max1 = aabb1.x + aabb1.hw\n            ,max2 = aabb2.x + aabb2.hw\n            ;\n\n        // first check x-axis\n\n        if ( (min2 <= max1 && max1 <= max2) || (min1 <= max2 && max2 <= max1) ){\n            // overlap in x-axis\n            // check y...\n            min1 = aabb1.y - aabb1.hh;\n            min2 = aabb2.y - aabb2.hh;\n            max1 = aabb1.y + aabb1.hh;\n            max2 = aabb2.y + aabb2.hh;\n\n            return (min2 <= max1 && max1 <= max2) || (min1 <= max2 && max2 <= max1);\n        }\n\n        // they don't overlap\n        return false;\n    };\n\n}());\n\n\n// ---\n// inside: src/math/gjk.js\n\n(function(){\n\n    // the algorithm doesn't always converge for curved shapes.\n    // need these constants to dictate how accurate we want to be.\n    var gjkAccuracy = 0.0001;\n    var gjkMaxIterations = 100;\n\n    // get the next search direction from two simplex points\n    var getNextSearchDir = function getNextSearchDir( ptA, ptB, dir ){\n\n        var ABdotB = ptB.normSq() - ptB.dot( ptA )\n            ,ABdotA = ptB.dot( ptA ) - ptA.normSq()\n            ;\n\n        // if the origin is farther than either of these points\n        // get the direction from one of those points to the origin\n        if ( ABdotB < 0 ){\n\n            return dir.clone( ptB ).negate();\n\n        } else if ( ABdotA > 0 ){\n\n            return dir.clone( ptA ).negate();\n\n        // otherwise, use the perpendicular direction from the simplex\n        } else {\n\n            // dir = AB = B - A\n            dir.clone( ptB ).vsub( ptA );\n            // if (left handed coordinate system)\n            // A cross AB < 0 then get perpendicular counterclockwise\n            return dir.perp( (ptA.cross( dir ) > 0) );\n        }\n    };\n\n    /** hide\n     * getClosestPoints( simplex ) -> Object\n     * - simplex (Array): The simplex\n     *\n     * Figure out the closest points on the original objects\n     * from the last two entries of the simplex\n     **/\n    var getClosestPoints = function getClosestPoints( simplex ){\n\n        // see http://www.codezealot.org/archives/153\n        // for algorithm details\n\n        // we know that the position of the last point\n        // is very close to the previous. (by nature of the distance test)\n        // this won't give great results for the closest\n        // points algorithm, so let's use the previous two\n        var len = simplex.length\n            ,last = simplex[ len - 2 ]\n            ,prev = simplex[ len - 3 ]\n            ,scratch = Physics.scratchpad()\n            ,A = scratch.vector().clone( last.pt )\n            // L = B - A\n            ,L = scratch.vector().clone( prev.pt ).vsub( A )\n            ,lambdaB\n            ,lambdaA\n            ;\n\n        if ( L.equals(Physics.vector.zero) ){\n\n            // oh.. it's a zero vector. So A and B are both the closest.\n            // just use one of them\n            return scratch.done({\n\n                a: last.a,\n                b: last.b\n            });\n        }\n\n        lambdaB = - L.dot( A ) / L.normSq();\n        lambdaA = 1 - lambdaB;\n\n        if ( lambdaA <= 0 ){\n            // woops.. that means the closest simplex point\n            // isn't on the line it's point B itself\n            return scratch.done({\n                a: prev.a,\n                b: prev.b\n            });\n        } else if ( lambdaB <= 0 ){\n            // vice versa\n            return scratch.done({\n                a: last.a,\n                b: last.b\n            });\n        }\n\n        // guess we'd better do the math now...\n        return scratch.done({\n            // a closest = lambdaA * Aa + lambdaB * Ba\n            a: A.clone( last.a ).mult( lambdaA ).vadd( L.clone( prev.a ).mult( lambdaB ) ).values(),\n            // b closest = lambdaA * Ab + lambdaB * Bb\n            b: A.clone( last.b ).mult( lambdaA ).vadd( L.clone( prev.b ).mult( lambdaB ) ).values()\n        });\n    };\n\n    /**\n     * Physics.gjk( support(axis)[, seed, checkOverlapOnly, debugFn] ) -> Object\n     * - support (Function): The support function. Must return an object containing\n       the witness points (`.a`, `.b`) and the support point (`.pt`).\n       Recommended to use simple objects.\n       Eg:\n       ```javascript\n       return {\n            a: { x: 1, y:2 },\n            b: { x: 3, y: 4 },\n            pt: { x: 2, y: 2 }\n       };\n       ```\n     * - axis (Physics.vector): The axis to search\n     * - seed (Physics.vector): The starting direction for the simplex (defaults to x-axis)\n     * - checkOverlapOnly (Boolean): only check whether there is an overlap, don't calculate the depth\n     * - debugFn (Function): For debugging. Called at every iteration with the current simplex.\n     *\n     * Implementation agnostic GJK function.\n     *\n     * Gilbert–Johnson–Keerthi object collison algorithm\n     * For general information about GJK see:\n     * - [www.codezealot.org/archives/88](http://www.codezealot.org/archives/88)\n     * - [mollyrocket.com/849](http://mollyrocket.com/849)\n     *\n     * The algorithm information returned:\n     * ```javascript\n     * {\n     *     overlap: Boolean,\n     *     simplex: [] // array containing simplex points as simple x/y objects\n     * }\n     * ```\n     **/\n    var gjk = function gjk( support, seed, checkOverlapOnly, debugFn ){\n\n        var overlap = false\n            ,noOverlap = false // if we're sure we're not overlapping\n            ,distance = false\n            ,simplex = []\n            ,simplexLen = 1\n            // setup a scratchpad of temporary cheap objects\n            ,scratch = Physics.scratchpad()\n            // use seed as starting direction or use x axis\n            ,dir = scratch.vector().clone(seed || Physics.vector.axis[ 0 ])\n            ,last = scratch.vector()\n            ,lastlast = scratch.vector()\n            // some temp vectors\n            ,v1 = scratch.vector()\n            ,v2 = scratch.vector()\n            ,ab\n            ,ac\n            ,sign\n            ,tmp\n            ,iterations = 0\n            ;\n\n        // get the first Minkowski Difference point\n        tmp = support( dir );\n        simplexLen = simplex.push( tmp );\n        last.clone( tmp.pt );\n        // negate d for the next point\n        dir.negate();\n\n        // start looping\n        while ( ++iterations ) {\n\n            // swap last and lastlast, to save on memory/speed\n            last.swap(lastlast);\n            // push a new point to the simplex because we haven't terminated yet\n            tmp = support( dir );\n            simplexLen = simplex.push( tmp );\n            last.clone( tmp.pt );\n\n            if ( debugFn ){\n                debugFn( simplex );\n            }\n\n            if ( last.equals(Physics.vector.zero) ){\n                // we happened to pick the origin as a support point... lucky.\n                overlap = true;\n                break;\n            }\n\n            // check if the last point we added actually passed the origin\n            if ( !noOverlap && last.dot( dir ) <= 0.0 ) {\n                // if the point added last was not past the origin in the direction of d\n                // then the Minkowski difference cannot possibly contain the origin since\n                // the last point added is on the edge of the Minkowski Difference\n\n                // if we just need the overlap...\n                if ( checkOverlapOnly ){\n                    break;\n                }\n\n                noOverlap = true;\n            }\n\n            // if it's a line...\n            if ( simplexLen === 2 ){\n\n                // otherwise we need to determine if the origin is in\n                // the current simplex and act accordingly\n\n                dir = getNextSearchDir( last, lastlast, dir );\n                // continue...\n\n            // if it's a triangle... and we're looking for the distance\n            } else if ( noOverlap ){\n\n                // if we know there isn't any overlap and\n                // we're just trying to find the distance...\n                // make sure we're getting closer to the origin\n                dir.normalize();\n                tmp = lastlast.dot( dir );\n                if ( Math.abs(tmp - last.dot( dir )) < gjkAccuracy ){\n\n                    distance = -tmp;\n                    break;\n                }\n\n                // if we are still getting closer then only keep\n                // the points in the simplex that are closest to\n                // the origin (we already know that last is closer\n                // than the previous two)\n                // the norm is the same as distance(origin, a)\n                // use norm squared to avoid the sqrt operations\n                if (lastlast.normSq() < v1.clone(simplex[ 0 ].pt).normSq()) {\n\n                    simplex.shift();\n\n                } else {\n\n                    simplex.splice(1, 1);\n                }\n\n                dir = getNextSearchDir( v1.clone(simplex[ 1 ].pt), v2.clone(simplex[ 0 ].pt), dir );\n                // continue...\n\n            // if it's a triangle\n            } else {\n\n                // we need to trim the useless point...\n\n                ab = ab || scratch.vector();\n                ac = ac || scratch.vector();\n\n                // get the edges AB and AC\n                ab.clone( lastlast ).vsub( last );\n                ac.clone( simplex[ 0 ].pt ).vsub( last );\n\n                // here normally people think about this as getting outward facing\n                // normals and checking dot products. Since we're in 2D\n                // we can be clever...\n                sign = ab.cross( ac ) > 0;\n\n                if ( sign ^ (last.cross( ab ) > 0) ){\n\n                    // ok... so there's an XOR here... don't freak out\n                    // remember last = A = -AO\n                    // if AB cross AC and AO cross AB have the same sign\n                    // then the origin is along the outward facing normal of AB\n                    // so if AB cross AC and A cross AB have _different_ (XOR) signs\n                    // then this is also the case... so we proceed...\n\n                    // point C is dead to us now...\n                    simplex.shift();\n\n                    // if we haven't deduced that we've enclosed the origin\n                    // then we know which way to look...\n                    // morph the ab vector into its outward facing normal\n                    ab.perp( !sign );\n\n                    // swap\n                    dir.swap( ab );\n\n                    // continue...\n\n                    // if we get to this if, then it means we can continue to look along\n                    // the other outward normal direction (ACperp)\n                    // if we don't see the origin... then we must have it enclosed\n                } else if ( sign ^ (ac.cross( last ) > 0) ){\n                    // then the origin is along the outward facing normal\n                    // of AC; (ACperp)\n\n                    // point B is dead to us now...\n                    simplex.splice(1, 1);\n\n                    ac.perp( sign );\n\n                    // swap\n                    dir.swap( ab );\n\n                    // continue...\n\n                } else {\n\n                    // we have enclosed the origin!\n                    overlap = true;\n                    // fewf... take a break\n                    break;\n                }\n            }\n\n            // woah nelly... that's a lot of iterations.\n            // Stop it!\n            if (iterations > gjkMaxIterations){\n                scratch.done();\n                return {\n                    simplex: simplex,\n                    iterations: iterations,\n                    distance: 0,\n                    maxIterationsReached: true\n                };\n            }\n        }\n\n        // free workspace\n        scratch.done();\n\n        tmp = {\n            overlap: overlap,\n            simplex: simplex,\n            iterations: iterations\n        };\n\n        if ( distance !== false ){\n\n            tmp.distance = distance;\n            tmp.closest = getClosestPoints( simplex );\n        }\n\n        return tmp;\n    };\n\n    Physics.gjk = gjk;\n\n})();\n\n\n// ---\n// inside: src/math/statistics.js\n\n(function(){\n\n    Physics.statistics = {\n        /**\n         * Physics.statistics.pushRunningAvg( v, k, m, s ) -> Array\n         * - v (Number): is value to push\n         * - k (Number): is num elements\n         * - m (Number): is current mean\n         * - s (Number): is current s value\n         * + (Array): Returns a 2 element array containing the next mean, and s value\n         *\n         * Push a value to a running average calculation.\n         * see [http://www.johndcook.com/blog/standard_deviation]\n         *\n         * Note: variance can be calculated from the \"s\" value by multiplying it by `1/(k-1)`\n         **/\n        pushRunningAvg: function( v, k, m, s ){\n\n            var x = v - m;\n\n            // Mk = Mk-1+ (xk – Mk-1)/k\n            // Sk = Sk-1 + (xk – Mk-1)*(xk – Mk).\n            m += x / k;\n            s += x * (v - m);\n            return [m, s];\n        },\n\n        /**\n        * Physics.statistics.pushRunningVectorAvg( v, k, m[, s] )\n        * - v (Physics.vector): is vector to push\n        * - k (Number): is num elements\n        * - m (Physics.vector): is current mean\n        * - s (Physics.vector): is current s value\n        *\n        * Push a vector to a running vector average calculation.\n        * see [http://www.johndcook.com/blog/standard_deviation]\n        *\n        * Calculations are done in place. The `m` and `s` parameters are altered.\n        *\n        * Note: variance can be calculated from the \"s\" vector by multiplying it by `1/(k-1)`\n        *\n        * If s value is ommitted it won't be used.\n        **/\n        pushRunningVectorAvg: function( v, k, m, s ){\n            var invK = 1/k\n                ,x = v.get(0) - m.get(0)\n                ,y = v.get(1) - m.get(1)\n                ;\n\n            // Mk = Mk-1+ (xk – Mk-1)/k\n            // Sk = Sk-1 + (xk – Mk-1)*(xk – Mk).\n            m.add( x * invK, y * invK );\n\n            if ( s ){\n                x *= v.get(0) - m.get(0);\n                y *= v.get(1) - m.get(1);\n\n                s.add( x, y );\n            }\n        }\n    };\n})();\n\n\n// ---\n// inside: src/math/transform.js\n\n(function(){\n    \n    /**\n     * class Physics.transform\n     * \n     * Vector Transformations class for rotating and translating vectors\n     **/\n\n    /**\n     * new Physics.transform( [vect, angle, origin] )\n     * new Physics.transform( transform )\n     * - vect (Vectorish): Translation vector\n     * - transform (Physics.transform): Transform to copy\n     * - angle (Number): Angle (radians) to use for rotation\n     * - origin (Vectorish): Origin of the rotation\n     * \n     * Transform Constructor / Factory\n     **/\n    var Transform = function Transform( vect, angle, origin ) {\n\n        if (!(this instanceof Transform)){\n            return new Transform( vect, angle );\n        }\n\n        this.v = new Physics.vector();\n        this.o = new Physics.vector(); // origin of rotation\n        \n        if ( vect instanceof Transform ){\n\n            this.clone( vect );\n            return;\n        }\n\n        if (vect){\n            this.setTranslation( vect );\n        }\n\n        this.setRotation( angle || 0, origin );\n    };\n\n    /**\n     * Physics.transform#setTranslation( vect ) -> this\n     * - vect (Vectorish): The translation vector\n     * \n     * Set the translation portion of the transform.\n     **/\n    Transform.prototype.setTranslation = function( vect ){\n\n        this.v.clone( vect );\n        return this;\n    };\n\n    /**\n     * Physics.transform#setRotation( angle[, origin ] ) -> this\n     * - angle (Number): Angle (radians) to use for rotation\n     * - origin (Vectorish): Origin of the rotation\n     *\n     * Set the rotation portion of the transform\n     **/\n    Transform.prototype.setRotation = function( angle, origin ){\n\n        this.cosA = Math.cos( angle );\n        this.sinA = Math.sin( angle );\n\n        if ( origin ){\n            this.o.clone( origin );\n        } else {\n            this.o.zero();\n        }\n\n        return this;\n    };\n\n    /**\n     * Physics.transform#clone( [transform] ) -> this|Physics.transform\n     * - transform (Physics.transform): Transform to copy\n     * + (this): For chaining\n     * + (Physics.transform): New copy of `this` if none is specified as an argument\n     * \n     * Clone another transform. Or clone self into new transform.\n     **/\n    Transform.prototype.clone = function( t ){\n\n        if ( t ){\n\n            this.setTranslation( t.v );\n            this.cosA = t.cosA;\n            this.sinA = t.sinA;\n            this.o.clone( t.o );\n\n            return this;\n        }\n\n        return new Transform( this );\n    };\n\n    Physics.transform = Transform;\n\n})();\n\n// ---\n// inside: src/math/vector.js\n\n(function(window){\n\n    // http://jsperf.com/vector-storage-test/2\n\n    // cached math functions\n    // TODO: might be faster not to do this???\n    var sqrt = Math.sqrt\n        ,min = Math.min\n        ,max = Math.max\n        ,acos = Math.acos\n        ,atan2 = Math.atan2\n        ,TWOPI = Math.PI * 2\n        ,typedArrays = !!window.Float64Array\n        ;\n\n    /**\n     * class Physics.vector\n     *\n     * The vector class and factory function.\n     *\n     * Call `Physics.vector` with the same arguments as\n     * [[new Physics.vector]] to create an instance.\n     *\n     * The vector methods mostly modify the vector instance.\n     * This makes computations faster because creating vectors\n     * is avoided.\n     *\n     * Creating vectors is generally an expensive operation\n     * so try to avoid doing this in the simulation loop.\n     * Instead you can use [[Physics.scratchpad]] to get\n     * temporary vectors for use in performance critical\n     * code.\n     *\n     * _Note_: The coordinate system is left-handed, meaning that\n     * the clockwise angular direction is positive. This has implications\n     * for the cross-product rule.\n     **/\n\n    /** section: Special\n     * class Vectorish\n     *\n     * Any object with `.x` and `.y` properties.\n     *\n     * A `Vectorish` isn't really a class. In this documentation, when\n     * an argument is specified as a `Vectorish` it means either a true\n     * [[Physics.vector]] instance, or an object literal with `.x` and `.y`\n     * properties.\n     **/\n\n    /**\n     * new Physics.vector( x, y )\n     * new Physics.vector( vect )\n     * - x (Number): The x coordinate\n     * - y (Number): The y coordinate\n     * - vect (Vectorish): A vector-like object to clone\n     *\n     * Vector Constructor.\n     **/\n    var Vector = function Vector( x, y ) {\n\n        // enforce instantiation\n        if ( !(this instanceof Vector) ){\n\n            return new Vector( x, y );\n        }\n\n        // arrays to store values\n        // x = _[0]\n        // y = _[1]\n        // norm = _[3]\n        // normsq = _[4]\n\n        /** internal\n         * Physics.vector#_\n         *\n         * Private storage array for data.\n         *\n         * Do not access this directly. Private. Keep out.\n         **/\n        if (typedArrays){\n            this._ = new Float64Array(5);\n        } else {\n            this._ = [];\n        }\n\n        if (x && (x.x !== undefined || x._ && x._.length)){\n\n            this.clone( x );\n\n        } else {\n\n            this.recalc = true; //whether or not recalculate norms\n            this.set( x, y );\n        }\n    };\n\n    Object.defineProperties( Vector.prototype, {\n        /**\n         * Physics.vector#x\n         *\n         * Getter/setter property for the x coordinate.\n         **/\n        x: {\n            get: function(){\n                return +this._[0];\n            },\n            set: function( x ){\n                x = +x || 0;\n                this.recalc = ( x === this._[0] );\n                this._[0] = x;\n            }\n        },\n        /**\n         * Physics.vector#y\n         *\n         * Getter/setter property for the y coordinate.\n         **/\n        y: {\n            get: function(){\n                return +this._[1];\n            },\n            set: function( y ){\n                y = +y || 0;\n                this.recalc = ( y === this._[1] );\n                this._[1] = y;\n            }\n        }\n    });\n\n    //\n    // Methods\n    //\n\n    /**\n     * Physics.vector#set( x, y ) -> this\n     * - x (Number): x coordinate\n     * - y (Number): y coordinate\n     *\n     * Sets the x and y components of this vector.\n     **/\n    Vector.prototype.set = function( x, y ) {\n\n        this.recalc = true;\n\n        this._[0] = +x || 0;\n        this._[1] = +y || 0;\n        return this;\n    };\n\n    /** deprecated: 0.6.0..1.0.0\n     * Physics.vector#get( idx ) -> Number\n     * - idx (Number): The coordinate index (0 or 1)\n     *\n     * Get the x or y component by index.\n     **/\n    Vector.prototype.get = function( n ){\n\n        return this._[ n ];\n    };\n\n    /**\n     * Physics.vector#vadd( v ) -> this\n     * - v (Physics.vector): vector to add\n     *\n     * Add a [[Physics.vector]] to `this`.\n     **/\n    Vector.prototype.vadd = function( v ) {\n\n        this.recalc = true;\n\n        this._[0] += v._[0];\n        this._[1] += v._[1];\n        return this;\n    };\n\n    /**\n     * Physics.vector#vsub( v ) -> this\n     * - v (Physics.vector): vector to subtract\n     *\n     * Subtract a [[Physics.vector]] from `this`.\n     **/\n    Vector.prototype.vsub = function( v ) {\n\n        this.recalc = true;\n\n        this._[0] -= v._[0];\n        this._[1] -= v._[1];\n        return this;\n    };\n\n    /**\n     * Physics.vector#add( x, y ) -> this\n     * - x (Number): amount to add to the x coordinate\n     * - y (Number): amount to add to the y coordinate\n     *\n     * Add scalars [[Physics.vector]] to the coordinates.\n     **/\n    Vector.prototype.add = function( x, y ){\n\n        this.recalc = true;\n\n        this._[0] += +x || 0;\n        this._[1] += +y || 0;\n        return this;\n    };\n\n    /**\n     * Physics.vector#sub( x, y ) -> this\n     * - x (Number): amount to subtract from the x coordinate\n     * - y (Number): amount to subtract from the y coordinate\n     *\n     * Subtract scalars [[Physics.vector]] from the coordinates.\n     **/\n    Vector.prototype.sub = function( x, y ){\n\n        this.recalc = true;\n\n        this._[0] -= x;\n        this._[1] -= y === undefined? 0 : y;\n        return this;\n    };\n\n    /**\n     * Physics.vector#mult( m ) -> this\n     * - m (Number): amount to multiply this vector by\n     *\n     * Multiply this by a scalar quantity.\n     *\n     * Same as scaling the vector by an amount `m`.\n     **/\n    Vector.prototype.mult = function( m ) {\n\n        if ( !this.recalc ){\n\n            this._[4] *= m * m;\n            this._[3] *= m;\n        }\n\n        this._[0] *= m;\n        this._[1] *= m;\n        return this;\n    };\n\n    /**\n     * Physics.vector#dot( v ) -> Number\n     * - v (Physics.vector): The other vector\n     *\n     * Compute the dot product of this vector with `v`.\n     **/\n    Vector.prototype.dot = function( v ) {\n\n        return (this._[0] * v._[0]) + (this._[1] * v._[1]);\n    };\n\n    /**\n     * Physics.vector#cross( v ) -> Number\n     * - v (Physics.vector): The other vector\n     *\n     * Compute the (left-handed) cross product of this vector with `v`.\n     **/\n    Vector.prototype.cross = function( v ) {\n\n        return ( - this._[0] * v._[1]) + (this._[1] * v._[0]);\n    };\n\n    /**\n     * Physics.vector#proj( v ) -> Number\n     * - v (Physics.vector): The other vector\n     *\n     * Compute the [scalar projection](http://en.wikipedia.org/wiki/Vector_projection#Scalar_projection_2) of this along `v`.\n     **/\n    Vector.prototype.proj = function( v ){\n\n        return this.dot( v ) / v.norm();\n    };\n\n\n    /**\n     * Physics.vector#vproj( v ) -> this\n     * - v (Physics.vector): The other vector\n     *\n     * Compute the [vector projection](http://en.wikipedia.org/wiki/Vector_projection#Vector_projection_2) of this along `v` and copy the result into this vector.\n     **/\n    Vector.prototype.vproj = function( v ){\n\n        var m = this.dot( v ) / v.normSq();\n        return this.clone( v ).mult( m );\n    };\n\n    /**\n     * Physics.vector#angle( [v] ) -> Number\n     * - v (Physics.vector): The other vector\n     * + (Number): The angle in radians between this vector and the x-axis OR `v` if specified\n     *\n     * Compute the angle between `this` and vector `v` or this and x axis.\n     **/\n    Vector.prototype.angle = function( v ){\n\n        var ang;\n\n        if ( this.equals( Vector.zero ) ){\n\n            if ( v ){\n                return v.angle();\n            } else {\n                return NaN;\n            }\n\n        } else {\n\n            if ( v && !v.equals( Vector.zero ) ){\n                ang = atan2( this._[1] * v._[0] - this._[0] * v._[1], this._[0] * v._[0] + this._[1] * v._[1]);\n            } else {\n                ang = atan2( this._[ 1 ], this._[ 0 ] );\n            }\n        }\n\n        while (ang > Math.PI){\n            ang -= TWOPI;\n        }\n\n        while (ang < -Math.PI){\n            ang += TWOPI;\n        }\n\n        return ang;\n    };\n\n    /**\n     * Physics.vector#angle2( left, right ) -> Number\n     * - left (Physics.vector): The position on the left\n     * - right (Physics.vector): The position on the right\n     *\n     * Compute the angle created between three points; left -> this -> right.\n     **/\n    Vector.prototype.angle2 = function( left, right ){\n\n        var x1 = left._[0] - this._[0]\n            ,y1 = left._[1] - this._[1]\n            ,x2 = right._[0] - this._[0]\n            ,y2 = right._[1] - this._[1]\n            ,ang = atan2( y1 * x2 - x1 * y2, x1 * x2 + y1 * y2)\n            ;\n\n        while (ang > Math.PI){\n            ang -= TWOPI;\n        }\n\n        while (ang < -Math.PI){\n            ang += TWOPI;\n        }\n\n        return ang;\n    };\n\n    /**\n     * Physics.vector#norm() -> Number\n     *\n     * Compute the norm (length) of this vector.\n     **/\n    Vector.prototype.norm = function() {\n\n        if (this.recalc){\n            this.recalc = false;\n            this._[4] = (this._[0] * this._[0] + this._[1] * this._[1]);\n            this._[3] = sqrt( this._[4] );\n        }\n\n        return this._[3];\n    };\n\n    /**\n     * Physics.vector#normSq() -> Number\n     *\n     * Compute the norm (length) squared of this vector.\n     **/\n    Vector.prototype.normSq = function() {\n\n        if (this.recalc){\n            this.recalc = false;\n            this._[4] = (this._[0] * this._[0] + this._[1] * this._[1]);\n            this._[3] = sqrt( this._[4] );\n        }\n\n        return this._[4];\n    };\n\n    /**\n     * Physics.vector#dist( v ) -> Number\n     * - v (Physics.vector): The other vector\n     *\n     * Compute the distance from this vector to another vector `v`.\n     **/\n    Vector.prototype.dist = function( v ) {\n\n        var dx, dy;\n        return sqrt(\n            (dx = (v._[0] - this._[0])) * dx +\n            (dy = (v._[1] - this._[1])) * dy\n        );\n    };\n\n    /**\n     * Physics.vector#distSq( v ) -> Number\n     * - v (Physics.vector): The other vector\n     *\n     * Compute the distance squared from this vector to another vector `v`.\n     **/\n    Vector.prototype.distSq = function( v ) {\n\n        var dx, dy;\n        return (\n            (dx = (v._[0] - this._[0])) * dx +\n            (dy = (v._[1] - this._[1])) * dy\n        );\n    };\n\n    /**\n     * Physics.vector#perp( [ccw] ) -> this\n     * - ccw (Boolean): flag to indicate that we should rotate counterclockwise\n     *\n     * Change this vector into a vector that will be perpendicular.\n     *\n     * In other words, rotate by (+-) 90 degrees.\n     **/\n    Vector.prototype.perp = function( ccw ) {\n\n        var tmp = this._[0]\n            ;\n\n        if ( ccw ){\n\n            // x <-> y\n            // negate y\n            this._[0] = this._[1];\n            this._[1] = -tmp;\n\n        } else {\n\n            // x <-> y\n            // negate x\n            this._[0] = -this._[1];\n            this._[1] = tmp;\n        }\n\n        return this;\n    };\n\n    /**\n     * Physics.vector#normalize() -> this\n     *\n     * Normalise this vector, making it a unit vector.\n     **/\n    Vector.prototype.normalize = function() {\n\n        var m = this.norm();\n\n        // means it's a zero Vector\n        if ( m === 0 ){\n            return this;\n        }\n\n        m = 1/m;\n\n        this._[0] *= m;\n        this._[1] *= m;\n\n        this._[3] = 1.0;\n        this._[4] = 1.0;\n\n        return this;\n    };\n\n    /**\n     * Physics.vector#transform( t ) -> this\n     * - t (Physics.transform): The transformation to apply\n     *\n     * Apply a [[Physics.transform]] to this vector.\n     **/\n    Vector.prototype.transform = function( t ){\n\n        var sinA = t.sinA\n            ,cosA = t.cosA\n            ,x = t.o._[ 0 ]\n            ,y = t.o._[ 1 ]\n            ;\n\n        this._[ 0 ] -= x;\n        this._[ 1 ] -= y;\n\n        // rotate about origin \"o\" then translate\n        return this.set(\n            this._[ 0 ] * cosA - this._[ 1 ] * sinA + x + t.v._[ 0 ],\n            this._[ 0 ] * sinA + this._[ 1 ] * cosA + y + t.v._[ 1 ]\n        );\n    };\n\n    /**\n     * Physics.vector#transformInv( t ) -> this\n     * - t (Physics.transform): The transformation to apply the inverse of\n     *\n     * Apply an inverse [[Physics.transform]] to this vector.\n     **/\n    Vector.prototype.transformInv = function( t ){\n\n        var sinA = t.sinA\n            ,cosA = t.cosA\n            ,x = t.o._[ 0 ]\n            ,y = t.o._[ 1 ]\n            ;\n\n        this._[ 0 ] -= x + t.v._[ 0 ];\n        this._[ 1 ] -= y + t.v._[ 1 ];\n\n        // inverse translate then inverse rotate about origin \"o\"\n        return this.set(\n            this._[ 0 ] * cosA + this._[ 1 ] * sinA + x,\n            - this._[ 0 ] * sinA + this._[ 1 ] * cosA + y\n        );\n    };\n\n    /**\n     * Physics.vector#rotate( t ) -> this\n     * Physics.vector#rotate( ang[, o] ) -> this\n     * - t (Physics.transform): The transformation to apply the rotational part of\n     * - ang (Number): The angle (in radians), to rotate by\n     * - o (Vectorish): The point of origin of the rotation\n     *\n     * Rotate this vector.\n     *\n     * An angle and rotation origin can be specified,\n     * or a transform can be specified and only the rotation\n     * portion of that transform will be applied\n     **/\n    Vector.prototype.rotate = function( t, o ){\n\n        var sinA\n            ,cosA\n            ,x = 0\n            ,y = 0\n            ;\n\n        if ( typeof t === 'number' ){\n            sinA = Math.sin( t );\n            cosA = Math.cos( t );\n\n            if ( o ){\n                x = o.x;\n                y = o.y;\n            }\n        } else {\n            sinA = t.sinA;\n            cosA = t.cosA;\n\n            x = t.o._[ 0 ];\n            y = t.o._[ 1 ];\n        }\n\n        this._[ 0 ] -= x;\n        this._[ 1 ] -= y;\n\n        return this.set(\n            this._[ 0 ] * cosA - this._[ 1 ] * sinA + x,\n            this._[ 0 ] * sinA + this._[ 1 ] * cosA + y\n        );\n    };\n\n    /**\n     * Physics.vector#rotateInv( t ) -> this\n     * - t (Physics.transform): The transformation to apply the inverse rotational part of\n     *\n     * Apply the inverse rotation of a transform.\n     *\n     * Only the inverse rotation portion of\n     * that transform will be applied.\n     **/\n    Vector.prototype.rotateInv = function( t ){\n\n        return this.set(\n            (this._[ 0 ] - t.o._[ 0 ]) * t.cosA + (this._[ 1 ] - t.o._[ 1 ]) * t.sinA + t.o._[ 0 ],\n            -(this._[ 0 ] - t.o._[ 0 ]) * t.sinA + (this._[ 1 ] - t.o._[ 1 ]) * t.cosA + t.o._[ 1 ]\n        );\n    };\n\n    /**\n     * Physics.vector#translate( t ) -> this\n     * - t (Physics.transform): The transformation to apply the translational part of\n     *\n     * Apply the translation of a transform.\n     *\n     * Only the translation portion of\n     * that transform will be applied.\n     **/\n    Vector.prototype.translate = function( t ){\n\n        return this.vadd( t.v );\n    };\n\n    /**\n     * Physics.vector#translateInv( t ) -> this\n     * - t (Physics.transform): The transformation to apply the inverse translational part of\n     *\n     * Apply the inverse translation of a transform.\n     *\n     * Only the inverse translation portion of\n     * that transform will be applied.\n     **/\n    Vector.prototype.translateInv = function( t ){\n\n        return this.vsub( t.v );\n    };\n\n\n    /**\n     * Physics.vector#clone( [v] ) -> this|Physics.vector\n     * - v (Vectorish): The vector-like object to clone\n     * + (this): If `v` is specified as an argument\n     * + (Physics.vector): A new vector instance that clones this vector, if no argument is specified\n     *\n     * Create a clone of this vector, or clone another vector into this instance.\n     *\n     * This is especially useful in vector algorithms\n     * that use temporary vectors (which most should).\n     * You can create temporary vectors and then do things like...\n     * ```\n     * temp.clone( otherVector );\n     * // compute things with temp...\n     * // then save the result\n     * result.clone( tmp );\n     * ```\n     **/\n    Vector.prototype.clone = function( v ) {\n\n        // http://jsperf.com/vector-storage-test\n\n        if ( v ){\n\n            if (!v._){\n\n                return this.set( v.x, v.y );\n            }\n\n            this.recalc = v.recalc;\n\n            if (!v.recalc){\n                this._[3] = v._[3];\n                this._[4] = v._[4];\n            }\n\n            this._[0] = v._[0];\n            this._[1] = v._[1];\n\n            return this;\n        }\n\n        return new Vector( this );\n    };\n\n    /**\n     * Physics.vector#swap( v ) -> this\n     * - v (Physics.vector): The other vector\n     *\n     * Swap values with other vector.\n     **/\n    Vector.prototype.swap = function( v ){\n\n        var _ = this._;\n        this._ = v._;\n        v._ = _;\n\n        _ = this.recalc;\n        this.recalc = v.recalc;\n        v.recalc = _;\n        return this;\n    };\n\n    /**\n     * Physics.vector#values() -> Object\n     *\n     * Get the coordinate values as an object literal.\n     **/\n    Vector.prototype.values = function(){\n\n        return {\n            x: this._[0],\n            y: this._[1]\n        };\n    };\n\n\n    /**\n     * Physics.vector#zero() -> this\n     *\n     * Set the coordinates of this vector to zero.\n     **/\n    Vector.prototype.zero = function() {\n\n        this._[3] = 0.0;\n        this._[4] = 0.0;\n\n        this._[0] = 0.0;\n        this._[1] = 0.0;\n        return this;\n    };\n\n    /**\n     * Physics.vector#negate() -> this\n     *\n     * Flip this vector in the opposite direction.\n     **/\n    Vector.prototype.negate = function( component ){\n\n        if (component !== undefined){\n\n            this._[ component ] = -this._[ component ];\n            return this;\n        }\n\n        this._[0] = -this._[0];\n        this._[1] = -this._[1];\n        return this;\n    };\n\n    /**\n     * Physics.vector#clamp( minV, maxV ) -> this\n     * - minV (Vectorish): The minimum vector\n     * - maxV (Vectorish): The maximum vector\n     *\n     * Constrain vector components to minima and maxima.\n     *\n     * The vector analog of [scalar clamping](http://en.wikipedia.org/wiki/Clamping_(graphics)).\n     **/\n    Vector.prototype.clamp = function( minV, maxV ){\n\n        this._[0] = min(max(this._[0], minV.x), maxV.x);\n        this._[1] = min(max(this._[1], minV.y), maxV.y);\n        this.recalc = true;\n        return this;\n    };\n\n    /**\n     * Physics.vector#toString() -> String\n     *\n     * Get a formatted string of this vector's coordinates.\n     **/\n    Vector.prototype.toString = function(){\n\n        return '('+this._[0] + ', ' + this._[1]+')';\n    };\n\n\n    /**\n     * Physics.vector#equals( v ) -> Boolean\n     * - v (Physics.vector): The other vector\n     *\n     * Determine if this vector equals another.\n     **/\n    Vector.prototype.equals = function( v ){\n\n        return this._[0] === v._[0] &&\n            this._[1] === v._[1] &&\n            this._[2] === v._[2];\n    };\n\n    /**\n     * Physics.vector.axis = Array\n     *\n     * Read-only axis vectors for general reference.\n     *\n     * Example:\n     *\n     * ```javascript\n     * Physics.vector.axis[0]; // The x axis unit vector\n     * Physics.vector.axis[1]; // The y axis unit vector\n     * ```\n     **/\n    Vector.axis = [\n        new Vector(1.0, 0.0),\n        new Vector(0.0, 1.0)\n    ];\n\n    /**\n     * Physics.vector.zero = zeroVector\n     *\n     * Read-only zero vector for reference\n     **/\n    Vector.zero = new Vector(0, 0);\n\n    // assign\n    Physics.vector = Vector;\n\n}(this)); // end Vector class\n\n\n// ---\n// inside: src/util/noconflict.js\n\n(function( window ){\n\n    var _Physics = window.Physics;\n\n    /**\n     * Physics.noConflict() -> Physics\n     * \n     * Restore the original reference to the global window.Physics variable.\n     * \n     * Does nothing if PhysicsJS doesn't have a reference in global scope\n     **/\n    Physics.noConflict = function(){\n\n        if ( window.Physics === Physics ) {\n            window.Physics = _Physics;\n        }\n        \n        return Physics;\n    };\n\n})( this );\n\n// ---\n// inside: src/util/decorator.js\n\n/** related to: factory\n * Physics.util.decorator( type [, protoDef ] ) -> Function\n * - type (String): The name of the factory you are creating\n * - protoDef (Object): The top-level prototype\n * + (Function): The factory function\n *\n * Facilitates creation of decorator factory functions.\n *\n * See the [[factory]] definition for the factory signatures.\n * [For full documentation and examples, please visit the wiki](https://github.com/wellcaffeinated/PhysicsJS/wiki/Fundamentals#the-factory-pattern).\n *\n * Example:\n *\n * ```javascript\n * var factory = Physics.util.decorator('factory', {\n *      // prototype methods...\n *      method: function( args ){\n *      }\n * });\n *\n * // define\n * factory( 'name', 'parent-name', function( parent ){\n *\n *      // extend further...\n *      return {\n *          // overrides\n *          init: function( cfg ){\n *              parent.init.call(this, cfg);\n *          }\n *      };\n * });\n *\n * // instantiate\n * var options = { key: 'val' };\n * var instance = factory( 'name', options );\n * ```\n **/\nvar Decorator = Physics.util.decorator = function Decorator( type, baseProto ){\n\n    var registry = {}\n        ,proto = {}\n        ;\n\n    // extend that supports getters/setters\n    // only extends functions\n    var extend = function extend( to, from ){\n        var desc, key;\n        for ( key in from ){\n            desc = Object.getOwnPropertyDescriptor( from, key );\n            if ( desc.get || desc.set ){\n\n                Object.defineProperty( to, key, desc );\n\n            } else if ( Physics.util.isFunction( desc.value ) ){\n\n                to[ key ] = desc.value;\n            }\n        }\n        return to;\n    };\n\n    // http://ejohn.org/blog/objectgetprototypeof/\n    /* jshint -W103 */\n    var getProto = Object.getPrototypeOf;\n    if ( typeof getProto !== 'function' ) {\n        if ( typeof 'test'.__proto__ === 'object' ) {\n            getProto = function(object){\n                return object.__proto__;\n            };\n        } else {\n            getProto = function(object){\n                // May break if the constructor has been tampered with\n                return object.constructor.prototype;\n            };\n        }\n    }\n    /* jshint +W103 */\n\n    var objectCreate = Object.create;\n    if (typeof objectCreate !== 'function') {\n        objectCreate = function (o) {\n            function F() {}\n            F.prototype = o;\n            return new F();\n        };\n    }\n\n    /*\n     * mixin( key, val )\n     * mixin( obj )\n     * - key (String): The method name\n     * - val (Function): The function to assign\n     * - obj (Object): object with many `key: fn` pairs\n     *\n     * Apply mixin methods to decorator base.\n     */\n    var mixin = function mixin( key, val ){\n\n        if ( typeof key === 'object' ){\n            proto = extend(proto, key);\n            proto.type = type;\n            return;\n        }\n\n        if ( key !== 'type' && Physics.util.isFunction( val ) ){\n            proto[ key ] = val;\n        }\n    };\n\n    // @TODO: not sure of the best way to make the constructor names\n    // transparent and readable in debug consoles...\n    mixin( baseProto );\n\n    /**  belongs to: Physics.util.decorator\n     * factory( name[, parentName], decorator[, cfg] )\n     * factory( name, cfg ) -> Object\n     * -  name       (String):  The class name\n     * -  parentName (String): The name of parent class to extend\n     * -  decorator  (Function): The decorator function that should define and return methods to extend (decorate) the base class\n     * -  cfg        (Object): The configuration to pass to the class initializer\n     *\n     * Factory function for definition and instantiation of subclasses.\n     *\n     * Use the first signature (once) to define it first.\n     * If defining without the \"cfg\" parameter, void will be returned. Otherwise the class instance will be returned.\n     *\n     * See [[Physics.util.decorator]] for more information.\n     **/\n    var factory = function factory( name, parentName, decorator, cfg ){\n\n        var instance\n            ,result\n            ,parent = proto\n            ,tmp\n            ;\n\n        // set parent if specified\n        if ( typeof parentName !== 'string' ){\n\n            // ... otherwise reassign parameters\n            cfg = decorator;\n            decorator = parentName;\n\n        } else {\n\n            // extend the specified module\n            parent = registry[ parentName ];\n\n            if ( !parent ){\n\n                throw 'Error: \"' + parentName + '\" ' + type + ' not defined';\n            }\n\n            parent = parent.prototype;\n        }\n\n        if ( typeof decorator === 'function' ){\n\n            result = registry[ name ];\n\n            if ( result ){\n\n                result.prototype = extend(result.prototype, decorator( getProto(result.prototype) ));\n\n            } else {\n                // newly defined\n                // store the new class\n                result = registry[ name ] = function constructor( opts ){\n                    if (this.init){\n                        this.init( opts );\n                    }\n                };\n\n                result.prototype = objectCreate( parent );\n                result.prototype = extend(result.prototype, decorator( parent, result.prototype ));\n            }\n\n            result.prototype.type = type;\n            result.prototype.name = name;\n\n        } else {\n\n            cfg = decorator || {};\n            result = registry[ name ];\n            if (!result){\n\n                throw 'Error: \"' + name + '\" ' + type + ' not defined';\n            }\n        }\n\n        if ( cfg ) {\n\n            // create a new instance from the provided decorator\n            return new result( cfg );\n        }\n    };\n\n    factory.mixin = mixin;\n\n    return factory;\n};\n\n\n// ---\n// inside: src/util/helpers.js\n\n/**\n * Physics.util.indexOf( arr, value ) -> Number\n * - arr (Array): The array to search\n * - value (Mixed): The value to find\n * + (Number): The index of `value` in the array OR `-1` if not found\n *\n * Fast indexOf implementation.\n **/\nPhysics.util.indexOf = function indexOf(arr, value) {\n    var fr = 0, bk = arr.length;\n    while (fr < bk) {\n        bk--;\n        if (arr[ fr ] === value) {\n            return fr;\n        }\n        if (arr[ bk ] === value) {\n            return bk;\n        }\n        fr++;\n    }\n    return -1;\n};\n\n\n// http://jsperf.com/array-destroy/87\n/**\n * Physics.util.clearArray( arr ) -> Array\n * - arr (Array): The array to clear\n * + (Array): The array passed in\n *\n * Quickly clear an array.\n **/\nPhysics.util.clearArray = function clearArray(arr){\n    var l = arr.length;\n    while( l-- ){\n        arr.pop();\n    }\n    return arr;\n};\n\n/**\n * Physics.util.throttle( fn, delay ) -> Function\n * - fn (Function): The function to throttle\n * - delay (Number): Time in milliseconds\n *\n * Ensure a function is only called once every specified time span.\n **/\nPhysics.util.throttle = function throttle( fn, delay, scope ){\n    var to\n        ,call = false\n        ,args\n        ,cb = function(){\n            clearTimeout( to );\n            if ( call ){\n                call = false;\n                to = setTimeout(cb, delay);\n                fn.apply(scope, args);\n            } else {\n                to = false;\n            }\n        }\n        ;\n\n    scope = scope || null;\n\n    return function(){\n        call = true;\n        args = arguments;\n        if ( !to ){\n            cb();\n        }\n    };\n};\n\n/**\n * Physics.util.options( def[, target] ) -> Function\n * - def (Object): Default options to set\n * - target (Object): Where to copy the options to. Defaults to the returned function.\n * + (Function): The options function\n *\n * Options helper to keep track of options. Call it with a config object. Access options directly on the function.\n *\n * Example:\n *\n * ```javascript\n * this.options = Physics.util.options({ foo: 'bar', opt: 'def' });\n * this.options({ opt: 'myVal' });\n *\n * this.options.foo; // === 'bar'\n * this.options.def; // === 'myVal'\n *\n * // can also change defaults later\n * this.options.defaults({ foo: 'baz' });\n *\n * // can add a change callback\n * this.options.onChange(function( opts ){\n *     // some option changed\n *     // opts is the target\n * });\n * ```\n **/\n// deep copy callback to extend deeper into options\nvar deepCopyFn = function( a, b ){\n\n    if ( Physics.util.isPlainObject( b ) ){\n\n        return Physics.util.extend({}, a, b, deepCopyFn );\n    }\n\n    return b !== undefined ? b : a;\n};\nPhysics.util.options = function( def, target ){\n\n    var _def = {}\n        ,fn\n        ,callbacks = []\n        ;\n\n    // set options\n    fn = function fn( options, deep ){\n\n        Physics.util.extend(target, options, deep ? deepCopyFn : null);\n        for ( var i = 0, l = callbacks.length; i < l; ++i ){\n            callbacks[ i ]( target );\n        }\n        return target;\n    };\n\n    // add defaults\n    fn.defaults = function defaults( def, deep ){\n        Physics.util.extend( _def, def, deep ? deepCopyFn : null );\n        Physics.util.defaults( target, _def, deep ? deepCopyFn : null );\n        return _def;\n    };\n\n    fn.onChange = function( cb ){\n        callbacks.push( cb );\n    };\n\n    target = target || fn;\n\n    fn.defaults( def );\n\n    return fn;\n};\n\n/**\n * Physics.util.pairHash( id1, id2 ) -> Number\n * - id1 (Number): The id of the first thing\n * - id2 (Number): The id of the second thing\n * + (Number): A unique numeric hash (valid for values < 2^16)\n *\n * Generate a unique numeric hash from two input IDs.\n *\n * Useful for speedy indexing of pairs.\n **/\nPhysics.util.pairHash = function( id1, id2 ){\n    id1 = id1|0;\n    id2 = id2|0;\n\n    if ( (id1|0) === (id2|0) ){\n\n        return -1;\n    }\n\n    // valid for values < 2^16\n    return ((id1|0) > (id2|0) ?\n        (id1 << 16) | (id2 & 0xFFFF) :\n        (id2 << 16) | (id1 & 0xFFFF))|0\n        ;\n};\n\n/**\n * Physics.util.bind( fn, scope[, args... ] ) -> Function\n * - fn (Function): The function to bind scope to\n * - scope (Object): The scope to give to `fn`\n * - args (Mixed): Arguments to send to `fn`\n *\n * Bind a scope to a function.\n *\n * Basically the same functionality as [Function.prototype.bind](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/bind).\n **/\nif ( !Function.prototype.bind ){\n    Physics.util.bind = function( fn, scope, args ){\n        args = Array.prototype.slice.call( arguments, 2 );\n        return function(){\n            return fn.apply( scope, args.concat( Array.prototype.slice.call(arguments) ) );\n        };\n    };\n} else {\n    Physics.util.bind = function( fn, scope, args ){\n        args = Array.prototype.slice.call( arguments, 1 );\n        return Function.prototype.bind.apply( fn, args );\n    };\n}\n\n/**\n * Physics.util.find( collection, fn( value, index, collection ) ) -> Mixed\n * - collection (Array): Collection of values to test\n * - fn (Function): The test function\n * - value (Mixed): The value to test\n * - index (Number): The index of value in collection\n * - collection (Array): The input collection\n *\n * Test an array of values against a test function\n * and return the first value for which the function\n * returns true.\n **/\nPhysics.util.find = function( collection, fn ){\n    var i\n        ,l = collection.length\n        ,val\n        ;\n\n    for ( i = 0; i < l; i++ ){\n        val = collection[ i ];\n        if ( fn( val, i, collection ) ){\n            return val;\n        }\n    }\n};\n\n/**\n * Physics.util.filter( collection, fn( value, index, collection ) ) -> Array\n * - collection (Array): Collection of values to test\n * - fn (Function): The test function\n * - value (Mixed): The value to test\n * - index (Number): The index of value in collection\n * - collection (Array): The input collection\n *\n * Test an array of values against a test function\n * and return another array of values for which\n * the test function returns true.\n **/\nPhysics.util.filter = function( collection, fn ){\n    var i\n        ,l = collection.length\n        ,val\n        ,matches = []\n        ;\n\n    for ( i = 0; i < l; i++ ){\n        val = collection[ i ];\n        if ( fn( val, i, collection ) ){\n            matches.push( val );\n        }\n    }\n\n    return matches;\n};\n\n// lodash methods\n\n(function(){\n/*\n * @license\n * Modified version of:\n * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/>\n * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/>\n * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE>\n * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors\n * Available under MIT license <http://lodash.com/license>\n */\n\n/* Used to determine if values are of the language type Object */\nvar objectTypes = {\n  'boolean': false,\n  'function': true,\n  'object': true,\n  'number': false,\n  'string': false,\n  'undefined': false\n};\nvar identity = function(a){ return a; };\nvar arrayClass = '[object Array]';\nvar objectClass = '[object Object]';\nvar nativeKeys = Object.keys;\nvar toString = Object.prototype.toString;\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\n/* Used as the size when optimizations are enabled for large arrays */\nvar largeArraySize = 75;\n/* Used to pool arrays and objects used internally */\nvar arrayPool = [],\n    objectPool = [];\n/* Used as the max size of the `arrayPool` and `objectPool` */\nvar maxPoolSize = 40;\nvar keyPrefix = +new Date() + '';\n\nfunction releaseArray(array) {\n  Physics.util.clearArray( array );\n  if (arrayPool.length < maxPoolSize) {\n    arrayPool.push(array);\n  }\n}\n\nfunction releaseObject(object) {\n  var cache = object.cache;\n  if (cache) {\n    releaseObject(cache);\n  }\n  object.array = object.cache = object.criteria = object.object = object.number = object.string = object.value = null;\n  if (objectPool.length < maxPoolSize) {\n    objectPool.push(object);\n  }\n}\n\nfunction getObject() {\n  return objectPool.pop() || {\n    'array': null,\n    'cache': null,\n    'criteria': null,\n    'false': false,\n    'index': 0,\n    'null': false,\n    'number': null,\n    'object': null,\n    'push': null,\n    'string': null,\n    'true': false,\n    'undefined': false,\n    'value': null\n  };\n}\n\nfunction getArray() {\n  return arrayPool.pop() || [];\n}\n\nfunction cacheIndexOf(cache, value) {\n  var type = typeof value;\n  cache = cache.cache;\n\n  if (type === 'boolean' || value == null) {\n    return cache[value] ? 0 : -1;\n  }\n  if (type !== 'number' && type !== 'string') {\n    type = 'object';\n  }\n  var key = type === 'number' ? value : keyPrefix + value;\n  cache = (cache = cache[type]) && cache[key];\n\n  return type === 'object' ?\n    (cache && Physics.util.indexOf(cache, value) > -1 ? 0 : -1) :\n    (cache ? 0 : -1);\n}\n\nfunction cachePush(value) {\n  var cache = this.cache,\n      type = typeof value;\n\n  if (type === 'boolean' || value == null) {\n    cache[value] = true;\n  } else {\n    if (type !== 'number' && type !== 'string') {\n      type = 'object';\n    }\n    var key = type === 'number' ? value : keyPrefix + value,\n        typeCache = cache[type] || (cache[type] = {});\n\n    if (type === 'object') {\n      (typeCache[key] || (typeCache[key] = [])).push(value);\n    } else {\n      typeCache[key] = true;\n    }\n  }\n}\n\nfunction createCache(array) {\n  var index = -1,\n      length = array.length,\n      first = array[0],\n      mid = array[(length / 2) | 0],\n      last = array[length - 1];\n\n  if (first && typeof first === 'object' &&\n      mid && typeof mid === 'object' && last && typeof last === 'object') {\n    return false;\n  }\n  var cache = getObject();\n  cache['false'] = cache['null'] = cache['true'] = cache['undefined'] = false;\n\n  var result = getObject();\n  result.array = array;\n  result.cache = cache;\n  result.push = cachePush;\n\n  while (++index < length) {\n    result.push(array[index]);\n  }\n  return result;\n}\n\nvar shimKeys = function(object) {\n  var index, iterable = object, result = [];\n  if (!iterable){ return result; }\n  if (!(objectTypes[typeof object])){ return result; }\n    for (index in iterable) {\n      if (hasOwnProperty.call(iterable, index)) {\n        result.push(index);\n      }\n    }\n  return result;\n};\n\nvar keys = !nativeKeys ? shimKeys : function(object) {\n  if (!Physics.util.isObject(object)) {\n    return [];\n  }\n  return nativeKeys(object);\n};\n\nvar idCounter = 0;\n/**\n * Physics.util.uniqueId( [prefix] ) -> String\n * - prefix (String): Prefix to the id\n *\n * Generate a unique id, optionally prefixed.\n **/\nPhysics.util.uniqueId = function uniqueId(prefix) {\n    var id = ++idCounter;\n    return '' + (prefix || '') + id;\n};\n\n/*\n * The base implementation of `_.random` without argument juggling or support\n * for returning floating-point numbers.\n *\n * @private\n * @param {number} min The minimum possible value.\n * @param {number} max The maximum possible value.\n * @returns {number} Returns a random number.\n */\nfunction baseRandom(min, max) {\n    return min + Math.floor(Math.random() * (max - min + 1));\n}\n\n/*\n * Creates an array of shuffled values, using a version of the Fisher-Yates\n * shuffle. See http://en.wikipedia.org/wiki/Fisher-Yates_shuffle.\n *\n * @static\n * @memberOf _\n * @category Collections\n * @param {Array|Object|string} collection The collection to shuffle.\n * @returns {Array} Returns a new shuffled collection.\n * @example\n *\n * _.shuffle([1, 2, 3, 4, 5, 6]);\n * // => [4, 1, 6, 3, 5, 2]\n */\nPhysics.util.shuffle = function(collection) {\n    var index = -1\n        ,length = collection ? collection.length : 0\n        ,result = Array(typeof length === 'number' ? length : 0)\n        ,i\n        ,l\n        ,value\n        ,rand\n        ;\n\n    for ( i = 0, l = collection.length; i < l; i++ ){\n        value = collection[ i ];\n        rand = baseRandom(0, ++index);\n        result[index] = result[rand];\n        result[rand] = value;\n    }\n    return result;\n};\n\n/**\n * Physics.util.isObject( val ) -> Boolean\n * - val (Mixed): The value to test\n *\n * Test if a value is an object.\n **/\nPhysics.util.isObject = function isObject(value) {\n    // check if the value is the ECMAScript language type of Object\n    // http://es5.github.io/#x8\n    // and avoid a V8 bug\n    // http://code.google.com/p/v8/issues/detail?id=2291\n    return !!(value && objectTypes[typeof value]);\n};\n\nfunction isFunction(value) {\n    return typeof value === 'function';\n}\n\n/**\n * Physics.util.isFunction( val ) -> Boolean\n * - val (Mixed): The value to test\n *\n * Test if a value is a function.\n **/\nPhysics.util.isFunction = isFunction;\n\n/**\n * Physics.util.isArray( val ) -> Boolean\n * - val (Mixed): The value to test\n *\n * Test if a value is an array.\n **/\nPhysics.util.isArray = Array.isArray || function(value) {\n  return value && typeof value === 'object' && typeof value.length === 'number' &&\n    toString.call(value) === arrayClass || false;\n};\n\nvar reNative = RegExp('^' +\n  String(toString)\n    .replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&')\n    .replace(/toString| for [^\\]]+/g, '.*?') + '$'\n);\nfunction isNative(value) {\n  return typeof value === 'function' && reNative.test(value);\n}\n\nfunction shimIsPlainObject(value) {\n  var ctor,\n      result;\n\n  // avoid non Object objects, `arguments` objects, and DOM elements\n  if (!(value && toString.call(value) === objectClass) ||\n      (ctor = value.constructor, isFunction(ctor) && !(ctor instanceof ctor))) {\n    return false;\n  }\n  // In most environments an object's own properties are iterated before\n  // its inherited properties. If the last iterated property is an object's\n  // own property then there are no inherited enumerable properties.\n  for (var key in value){\n    result = key;\n  }\n  return typeof result === 'undefined' || hasOwnProperty.call(value, result);\n}\n\n/**\n * Physics.util.isPlainObject( val ) -> Boolean\n * - val (Mixed): The value to test\n *\n * Test if a value is a plain javascript object.\n **/\nPhysics.util.isPlainObject = !Object.getPrototypeOf ? shimIsPlainObject : function(value) {\n  if (!(value && toString.call(value) === objectClass)) {\n    return false;\n  }\n  var valueOf = value.valueOf,\n      objProto = isNative(valueOf) && (objProto = Object.getPrototypeOf(valueOf)) && Object.getPrototypeOf(objProto);\n\n  return objProto ?\n    (value === objProto || Object.getPrototypeOf(value) === objProto) :\n    shimIsPlainObject(value);\n};\n\nfunction baseUniq(array, isSorted, callback) {\n  var index = -1,\n      indexOf = Physics.util.indexOf,\n      length = array ? array.length : 0,\n      result = [];\n\n  var isLarge = !isSorted && length >= largeArraySize && indexOf === Physics.util.indexOf,\n      seen = (callback || isLarge) ? getArray() : result;\n\n  if (isLarge) {\n    var cache = createCache(seen);\n    indexOf = cacheIndexOf;\n    seen = cache;\n  }\n  while (++index < length) {\n    var value = array[index],\n        computed = callback ? callback(value, index, array) : value;\n\n    if (isSorted ?\n          !index || seen[seen.length - 1] !== computed :\n          indexOf(seen, computed) < 0\n        ) {\n      if (callback || isLarge) {\n        seen.push(computed);\n      }\n      result.push(value);\n    }\n  }\n  if (isLarge) {\n    releaseArray(seen.array);\n    releaseObject(seen);\n  } else if (callback) {\n    releaseArray(seen);\n  }\n  return result;\n}\n\n/**\n * Physics.util.uniq( array, [isSorted, callback] ) -> Array\n * - array (Array): The array\n * - isSorted (Boolean): Flag to indicate the array is sorted\n * - callback (Function): Mapping function\n *\n * Create an array without duplicates.\n **/\nPhysics.util.uniq = function uniq(array, isSorted, callback) {\n  // juggle arguments\n  if (typeof isSorted !== 'boolean' && isSorted != null) {\n    callback = isSorted;\n    isSorted = false;\n  }\n  return baseUniq(array, isSorted, callback);\n};\n\nvar assign = function(object, source, guard) {\n  var index, iterable = object, result = iterable;\n  if (!iterable) { return result; }\n  var args = arguments,\n      argsIndex = 0,\n      callback,\n      argsLength = typeof guard === 'number' ? 2 : args.length;\n  if (argsLength > 2 && typeof args[argsLength - 1] === 'function') {\n    callback = args[--argsLength];\n  }\n  while (++argsIndex < argsLength) {\n    iterable = args[argsIndex];\n    if (iterable && objectTypes[typeof iterable]) {\n        var ownIndex = -1,\n            ownProps = objectTypes[typeof iterable] && keys(iterable),\n            length = ownProps ? ownProps.length : 0;\n\n        while (++ownIndex < length) {\n          index = ownProps[ownIndex];\n          result[index] = callback ? callback(result[index], iterable[index]) : iterable[index];\n        }\n    }\n  }\n  return result;\n};\n\n/**\n * Physics.util.extend( object, source...[, callback] ) -> Object\n * - object (Object): The destination object\n * - source (Object): The source objects\n * - callback (Function): The function to customize assigning values\n *\n * Implementation of [lodash.extend](http://lodash.com/docs#assign)\n **/\nPhysics.util.extend = assign;\n\n/**\n * Physics.util.defaults( object, source...[, callback] ) -> Object\n * - object (Object): The destination object\n * - source (Object): The source objects\n * - callback (Function): The function to customize assigning values\n *\n * Implementation of [lodash.defaults](http://lodash.com/docs#defaults).\n **/\nPhysics.util.defaults = function(object, source, guard) {\n  var index, iterable = object, result = iterable;\n  if (!iterable){ return result; }\n  var args = arguments,\n      argsIndex = 0,\n      argsLength = typeof guard === 'number' ? 2 : args.length;\n  while (++argsIndex < argsLength) {\n    iterable = args[argsIndex];\n    if (iterable && objectTypes[typeof iterable]) {\n        var ownIndex = -1,\n            ownProps = objectTypes[typeof iterable] && keys(iterable),\n            length = ownProps ? ownProps.length : 0;\n\n        while (++ownIndex < length) {\n          index = ownProps[ownIndex];\n          if (typeof result[index] === 'undefined') {\n              result[index] = iterable[index];\n          }\n        }\n    }\n  }\n  return result;\n};\n\n/**\n * Physics.util.sortedIndex( array, value[, callback] ) -> Number\n * - array (Array): The array to inspect\n * - value (Mixed): The value to evaluate\n * - callback (Function): Function called per iteration\n *\n * Implementation of [lodash.sortedIndex](http://lodash.com/docs#sortedIndex).\n **/\nPhysics.util.sortedIndex = function sortedIndex(array, value, callback) {\n  var low = 0,\n      high = array ? array.length : low;\n\n  // explicitly reference `identity` for better inlining in Firefox\n  callback = callback || identity;\n  value = callback(value);\n\n  /* jshint -W030 */\n  while (low < high) {\n    var mid = (low + high) >>> 1;\n    (callback(array[mid]) < value) ?\n      low = mid + 1 :\n      high = mid;\n  }\n  /* jshint +W030 */\n  return low;\n};\n\n})();\n\n\n// ---\n// inside: src/util/scratchpad.js\n\n/*\n * scratchpad\n * thread-safe management of temporary (voletile)\n * objects for use in calculations\n * https://github.com/wellcaffeinated/scratchpad.js\n */\nPhysics.scratchpad = (function(){\n\n    // Errors\n    var SCRATCH_USAGE_ERROR = 'Error: Scratchpad used after .done() called. (Could it be unintentionally scoped?)';\n    var SCRATCH_INDEX_OUT_OF_BOUNDS = 'Error: Scratchpad usage space out of bounds. (Did you forget to call .done()?)';\n    var SCRATCH_MAX_REACHED = 'Error: Too many scratchpads created. (Did you forget to call .done()?)';\n    var ALREADY_DEFINED_ERROR = 'Error: Object is already registered.';\n\n    // cache previously created scratches\n    var scratches = [];\n    var numScratches = 0;\n    var Scratch, Scratchpad;\n\n    var regIndex = 0;\n\n\n    /** belongs to: Physics.scratchpad\n     * class Scratch\n     *\n     * A scratchpad session.\n     *\n     * This class keeps track of temporary objects used\n     * in this session and releases them when finished (call to `.done()`).\n     *\n     * Use this to retrieve temporary objects:\n     * - `.vector()`: retrieve a temporary [[Physics.vector]]\n     * - `.transform()`: retrieve a temporary [[Physics.transform]]\n     *\n     * See [[Physics.scratchpad]] for more info.\n     **/\n    Scratch = function Scratch(){\n\n        // private variables\n        this._active = false;\n        this._indexArr = [];\n\n        if (++numScratches >= Scratchpad.maxScratches){\n            throw SCRATCH_MAX_REACHED;\n        }\n    };\n\n    Scratch.prototype = {\n\n        /**\n         * Scratch#done( [val] ) -> Mixed\n         * - val (Mixed): No effect on this method, just passed on to the return value so you can do things like:\n         return scratch.done( myReturnVal );\n         * + (Mixed): Whatever you specified as `val`\n         *\n         * Declare that your work is finished.\n         *\n         * Release temp objects for use elsewhere. Must be called when immediate work is done.\n         *\n         * You can wrap the return value in scratch.done() so that you don't forget to call it.\n         *\n         * Example:\n         *\n         * ```javascript\n         * return scratch.done( myReturnValue );\n         * ```\n         **/\n        done: function( val ){\n\n            this._active = false;\n            var s;\n            for ( var i = 0; i < regIndex; ++i ){\n\n                this[ i ] = 0;\n            }\n\n            // add it back to the scratch stack for future use\n            scratches.push( this );\n            return val;\n        }\n    };\n\n\n    // API\n\n    /**\n     * Physics.scratchpad( [fn] ) -> Scratch|Function\n     * - fn (Function): Some function you'd like to wrap in a scratch session. First argument is the scratch instance.\n     * + (Function): The wrapped function (if `fn` arg specified) that can be reused like the original minus the first (scratch) parameter.\n     * + (Scratch): The scratch session.\n     *\n     * Get a new scratch session to work from or wrap a function in a scratch session.\n     *\n     * Call `.done()` on it when finished.\n     *\n     * Example:\n     *\n     * ```javascript\n     * // get a scratch session manually\n     * var myAlg = function( scratch, arg1, arg2, ... ){\n     *     var scratch = Physics.scratchpad()\n     *     ,vec = scratch.vector().set( 0, 0 ) // need to reinitialize... it's recycled!\n     *     ;\n     *     // ...\n     *     return scratch.done( result );\n     * };\n     * // later...\n     * while( awesome ){\n     *     myAlg( arg1, arg2, ... );\n     * }\n     * ```\n     *\n     * Example:\n     *\n     * ```javascript\n     * // wrap a function in a scratch session\n     * var myAlg = Physics.scratchpad(function( scratch, arg1, arg2, ... ){\n     *     var vec = scratch.vector().set( 0, 0 ); // need to reinitialize... it's recycled!\n     *     //...\n     *     return result;\n     * });\n     * // later...\n     * while( awesome ){\n     *     myAlg( arg1, arg2, ... );\n     * }\n     * ```\n     **/\n    Scratchpad = function Scratchpad( fn ){\n\n        if ( fn ){\n            return Scratchpad.fn( fn );\n        }\n\n        var scratch = scratches.pop() || new Scratch();\n        scratch._active = true;\n        return scratch;\n    };\n\n    // options\n    Scratchpad.maxScratches = 100; // maximum number of scratches\n    Scratchpad.maxIndex = 20; // maximum number of any type of temp objects\n\n    /**\n     * Physics.scratchpad.fn( fn ) -> Function\n     * - fn (Function): Some function you'd like to wrap in a scratch session. First argument is the scratch instance. See [[Physics.scratchpad]].\n     * + (Function): The wrapped function that can be reused like the original minus the first (scratch) parameter.\n     *\n     * Wrap a function in a scratch session.\n     *\n     * Same as calling `Physics.scratchpad( fn )` with a function specified.\n     **/\n    Scratchpad.fn = function( fn ){\n\n        var args = [];\n        for ( var i = 0, l = fn.length; i < l; i++ ){\n            args.push( i );\n        }\n\n        args = 'a' + args.join(',a');\n        /* jshint -W054 */\n        var handle = new Function('fn, scratches, Scratch', 'return function('+args+'){ '+\n               'var scratch = scratches.pop() || new Scratch( scratches );'+\n               'scratch._active = true;'+\n               'return scratch.done( fn(scratch, '+args+') );'+\n           '};'\n        );\n        /* jshint +W054 */\n\n        return handle(fn, scratches, Scratch);\n    };\n\n    /**\n     * Physics.scratchpad.register( name, constructor )\n     * - name (String): Name of the object class\n     * - constructor (Function): The object constructor\n     *\n     * Register a new object to be included in scratchpads.\n     *\n     * Example:\n     *\n     * ```javascript\n     * // register a hypothetical vector class...\n     * Physics.scratchpad.register('vector', Vector);\n     * ```\n     **/\n    Scratchpad.register = function register( name, constructor, options ){\n\n        var proto = Scratch.prototype\n            ,idx = regIndex++ // increase the scratch type index\n            ,stackname = '_' + name + 'Stack' // the name of the array stack\n            ,useFactory = options && options.useFactory\n            ;\n\n        if ( name in proto ) {\n            throw ALREADY_DEFINED_ERROR;\n        }\n\n        // create a new function on the prototype\n        Scratch.prototype[ name ] = function(){\n\n            // get the stack (or initialize it)\n            var stack = this[ stackname ] || (this[ stackname ] = [])\n                // we increase this index every time a voletile object is requested\n                // seems weird to store it on this as a number (ie: this.0, this.1)...\n                // but actually it's faster...\n                ,stackIndex = this[ idx ] | 0\n                ;\n\n            this[ idx ] = stackIndex + 1;\n\n            // if used after calling done...\n            if (!this._active){\n                throw SCRATCH_USAGE_ERROR;\n            }\n\n            // if too many objects created...\n            if (stackIndex >= Scratchpad.maxIndex){\n                throw SCRATCH_INDEX_OUT_OF_BOUNDS;\n            }\n\n            // return or create new instance\n            return stack[ stackIndex ] ||\n                    (stack[ stackIndex ] = useFactory ? constructor() : new constructor() );\n        };\n\n    };\n\n    // register some classes\n    Scratchpad.register('vector', Physics.vector);\n    Scratchpad.register('transform', Physics.transform);\n\n    return Scratchpad;\n\n})();\n\n\n// ---\n// inside: src/util/pubsub.js\n\n(function(){\n\n    var defaultPriority = 1;\n\n    function getPriority( val ){\n        return val._priority_;\n    }\n\n    // register a new scratch object so we can reuse event data\n    Physics.scratchpad.register('event', function(){ return {}; }, { useFactory: true });\n\n    /**\n     * class Physics.util.pubsub\n     *\n     * Fast pubsub implementation.\n     *\n     * Can be mixed into other classes easily.\n     **/\n    var PubSub = function PubSub(){\n\n        if (!(this instanceof PubSub)){\n            return new PubSub();\n        }\n    };\n\n    PubSub.prototype = {\n\n        /**\n         * Physics.util.pubsub#on( topic, fn( data, event )[, scope, priority] ) -> this\n         * Physics.util.pubsub#on( topicConfig[, scope, priority] ) -> this\n         * - topic (String): The topic name\n         * - topicConfig (Object): A config with key/value pairs of `{ topic: callbackFn, ... }`\n         * - fn (Function): The callback function (if not using Object as previous argument)\n         * - data (Mixed): The data sent from the call to `.emit()`\n         * - event (Object): Event data, holding `.topic`, the topic, and `.handler`, the `fn` callback.\n         * - scope (Object): The scope to bind callback to\n         * - priority (Number): The priority of the callback (higher is earlier)\n         *\n         * Subscribe callback(s) to a topic(s).\n         **/\n        on: function( topic, fn, scope, priority ){\n\n            var listeners\n                ,orig\n                ,idx\n                ;\n\n            // ensure topics hash is initialized\n            this._topics = this._topics || (this._topics = {});\n\n            // check if we're subscribing to multiple topics\n            // with an object\n            if ( Physics.util.isObject( topic ) ){\n\n                for ( var t in topic ){\n\n                    this.on( t, topic[ t ], fn, scope );\n                }\n\n                return this;\n            }\n\n            listeners = this._topics[ topic ] || (this._topics[ topic ] = []);\n            orig = fn;\n\n            if ( Physics.util.isObject( scope ) ){\n\n                fn = Physics.util.bind( fn, scope );\n                fn._bindfn_ = orig;\n                fn._one_ = orig._one_;\n                fn._scope_ = scope;\n\n            } else if ( priority === undefined ) {\n\n                priority = scope;\n            }\n\n            fn._priority_ = priority === undefined ? defaultPriority : priority;\n\n            idx = Physics.util.sortedIndex( listeners, fn, getPriority );\n\n            listeners.splice( idx, 0, fn );\n            return this;\n        },\n\n        /**\n         * Physics.util.pubsub#off( topic, fn[, scope] ) -> this\n         * Physics.util.pubsub#off( topicCfg ) -> this\n         * - topic (String): topic The topic name. Specify `true` to remove all listeners for all topics\n         * - topicCfg (Object): A config with key/value pairs of `{ topic: callbackFn, ... }`\n         * - fn (Function): The original callback function. Specify `true` to remove all listeners for specified topic\n         * - scope (Object): The scope the callback was bound to. This is important if you are binding methods that come from object prototypes.\n         *\n         * Unsubscribe callback(s) from topic(s).\n         **/\n        off: function( topic, fn, scope ){\n\n            var listeners\n                ,listn\n                ;\n\n            if ( !this._topics ){\n                // nothing subscribed\n                return this;\n            }\n\n            if ( topic === true ){\n                // purge all listeners\n                this._topics = {};\n                return this;\n            }\n\n            // check if we're subscribing to multiple topics\n            // with an object\n            if ( Physics.util.isObject( topic ) ){\n\n                for ( var t in topic ){\n\n                    this.off( t, topic[ t ] );\n                }\n\n                return this;\n            }\n\n            listeners = this._topics[ topic ];\n\n            if (!listeners){\n                return this;\n            }\n\n            if ( fn === true ){\n                // purge all listeners for topic\n                this._topics[ topic ] = [];\n                return this;\n            }\n\n            for ( var i = 0, l = listeners.length; i < l; i++ ){\n\n                listn = listeners[ i ];\n\n                if (\n                    (listn._bindfn_ === fn || listn === fn) &&\n                    ( (!scope) || listn._scope_ === scope) // check the scope too if specified\n                ){\n                    listeners.splice( i, 1 );\n                    break;\n                }\n            }\n\n            return this;\n        },\n\n        /**\n         * Physics.util.pubsub#emit( topic[, data] ) -> this\n         * - topic (String): The topic name\n         * - data (Mixed): The data to send\n         *\n         * Publish data to a topic.\n         **/\n        emit: function( topic, data ){\n\n            if ( !this._topics ){\n                // nothing subscribed\n                return this;\n            }\n\n            var listeners = this._topics[ topic ]\n                ,l = listeners && listeners.length\n                ,handler\n                ,e\n                ,scratch = Physics.scratchpad()\n                ;\n\n            if ( !l ){\n                return scratch.done(this);\n            }\n\n            e = scratch.event();\n            // event data\n            e.topic = topic;\n            e.handler = handler;\n\n            // reverse iterate so priorities work out correctly\n            while ( l-- ){\n\n                handler = listeners[ l ];\n                handler( data, e );\n\n                // if _one_ flag is set, the unsubscribe\n                if ( handler._one_ ){\n                    listeners.splice( l, 1 );\n                }\n            }\n\n            return scratch.done(this);\n        },\n\n        /**\n         * Physics.util.pubsub#one( topic, fn( data, event )[, scope, priority] ) -> this\n         * Physics.util.pubsub#one( topicConfig[, scope, priority] ) -> this\n         * - topic (String): The topic name\n         * - topicConfig (Object): A config with key/value pairs of `{ topic: callbackFn, ... }`\n         * - fn (Function): The callback function (if not using Object as previous argument)\n         * - data (Mixed): The data sent from the call to `.emit()`\n         * - event (Object): Event data, holding `.topic`, the topic, and `.handler`, the `fn` callback.\n         * - scope (Object): The scope to bind callback to\n         * - priority (Number): The priority of the callback (higher is earlier)\n         *\n         * Subscribe callback(s) to a topic(s), but only ONCE.\n         **/\n        one: function( topic, fn, scope ){\n\n            // check if we're subscribing to multiple topics\n            // with an object\n            if ( Physics.util.isObject( topic ) ){\n\n                for ( var t in topic ){\n\n                    this.one( t, topic[ t ], fn, scope );\n                }\n\n                return this;\n            }\n\n            // set the _one_ flag\n            fn._one_ = true;\n            this.on( topic, fn, scope );\n\n            return this;\n        }\n    };\n\n    Physics.util.pubsub = PubSub;\n})();\n\n\n// ---\n// inside: src/util/ticker.js\n\n/**\n * class Physics.util.ticker\n *\n * The Ticker _singleton_ for easily binding callbacks to animation loops (requestAnimationFrame).\n *\n * Requires window.requestAnimationFrame... so polyfill it if you need to.\n **/\n(function(window){\n\n    var active = true\n        ,ps = Physics.util.pubsub()\n        ,perf = window.performance\n        ;\n\n    function now(){\n        // http://updates.html5rocks.com/2012/05/requestAnimationFrame-API-now-with-sub-millisecond-precision\n        return (perf && perf.now) ?\n            (perf.now() + perf.timing.navigationStart) :\n            Date.now();\n    }\n\n    /*\n     * step( time )\n     * - time (Number): The current time\n     *\n     * Publish a tick to subscribed callbacks\n     */\n    function step(){\n\n        var time;\n\n        window.requestAnimationFrame( step );\n\n        if (!active){\n            return;\n        }\n\n        time = now();\n\n        if (!time){\n            return;\n        }\n\n        ps.emit( 'tick', time );\n    }\n\n    // start stepping if we can\n    if ( window.requestAnimationFrame ){\n        step();\n    } else {\n        active = false;\n    }\n\n    /**\n     * Physics.util.ticker.start() -> this\n     *\n     * Start the ticker\n     **/\n    function start(){\n\n        active = true;\n        return this;\n    }\n\n    /**\n     * Physics.util.ticker.stop() -> this\n     *\n     * Stop the ticker\n     **/\n    function stop(){\n\n        active = false;\n        return this;\n    }\n\n    /**\n     * Physics.util.ticker.on( listener( time ) ) -> this\n     * - listener (Function): The callback function\n     * - time (Number): The current timestamp\n     *\n     * Subscribe a callback to the ticker.\n     **/\n    function on( listener ){\n\n        ps.on('tick', listener);\n        return this;\n    }\n\n    /**\n     * Physics.util.ticker.off( listener ) -> this\n     * - listener (Function): The callback function previously bound\n     *\n     * Unsubscribe a callback from the ticker.\n     **/\n    function off( listener ){\n\n        ps.off('tick', listener);\n        return this;\n    }\n\n    /**\n     * Physics.util.ticker.isActive() -> Boolean\n     * + (Boolean): `true` if running, `false` otherwise.\n     *\n     * Determine if ticker is currently running.\n     **/\n    function isActive(){\n\n        return !!active;\n    }\n\n    // API\n    Physics.util.ticker = {\n        now: now,\n        start: start,\n        stop: stop,\n        on: on,\n        off: off,\n        isActive: isActive\n    };\n\n}(this));\n\n\n// ---\n// inside: src/core/query.js\n\n(function (window) {\n\n    /*\n     * Group helpers\n     */\n    var fnTrue = function(){ return !0; }; // return true\n    \n    var indexOf = Physics.util.indexOf;\n\n    /** hide\n     * wrapRule( fn( propVal ), prop ) -> Function\n     * - fn (Function): The test function\n     * - prop (String): The property name to test\n     * - propVal (Mixed): The property value\n     * \n     * Get test function to test on sub property.\n     **/\n    var wrapRule = function wrapRule( fn, prop ){\n        return function( thing ){\n            return fn( thing[ prop ] );\n        };\n    };\n\n    /** hide\n     * $eq( toMatch[, prop] ) -> Function\n     * - toMatch (Mixed): The value to match\n     * - prop (String): The property name to test\n     * \n     * Get an equality test function.\n     **/\n    var $eq = function $eq( toMatch, prop ){\n        return function( thing ){\n            \n            thing = prop ? thing[ prop ] : thing;\n\n            var fr = 0\n                ,bk\n                ;\n            \n            if ( Physics.util.isArray( thing ) ){\n\n                if ( Physics.util.isArray( toMatch ) ){\n                    // match all\n                    bk = thing.length;\n\n                    // check lengths\n                    if ( bk !== toMatch.length ){\n                        return false;\n                    }\n\n                    while ( fr < bk ){\n                        bk--;\n                        if (\n                            // check front\n                            (indexOf(toMatch, thing[ fr ]) === -1) ||\n                            // check back\n                            (indexOf(toMatch, thing[ bk ]) === -1)\n                        ) {\n                            return false;\n                        }\n                        fr++;\n                    }\n                    return true;\n                } else {\n                    // find in array\n                    return (indexOf( thing, toMatch ) > -1);\n                }\n            }\n\n            // exact match\n            return (thing === toMatch);\n        };\n    };\n\n    /** hide\n     * $ne( toMatch[, prop] ) -> Function\n     * - toMatch (Mixed): The value to match\n     * - prop (String): The property name to test\n     * \n     * Get a NOT equality test function.\n     **/\n    var $ne = function $ne( toMatch, prop ){\n        var fn = $eq( toMatch, prop );\n        return function( thing ){\n            return !fn( thing );\n        };\n    };\n\n    /** hide\n     * $in( toMatch[, prop] ) -> Function\n     * - toMatch (Array): The array to match\n     * - prop (String): The property name to test\n     * \n     * Get a test function for matching ANY in array\n     **/\n    var $in = function $in( toMatch, prop ){\n        return function( thing ){\n\n            thing = prop ? thing[ prop ] : thing;\n            \n            var fr = 0\n                ,bk\n                ;\n\n            if ( Physics.util.isArray( thing ) ){\n                bk = thing.length;\n\n                while( fr < bk ){\n                    bk--;\n                    if (\n                        // check front\n                        (indexOf(toMatch, thing[ fr ]) > -1) ||\n                        // check back\n                        (indexOf(toMatch, thing[ bk ]) > -1)\n                    ) {\n                        return true;\n                    }\n                    fr++;\n                }\n                return false;\n            }\n\n            // if thing matches any in array\n            return (indexOf(toMatch, thing) > -1);\n        };\n    };\n\n    /** hide\n     * $nin( toMatch[, prop] ) -> Function\n     * - toMatch (Array): The array to match\n     * - prop (String): The property name to test\n     * \n     * Get a test function for matching NOT ANY in array\n     **/\n    var $nin = function $nin( toMatch, prop ){\n        var fn = $in( toMatch, prop );\n        return function( thing ){\n            return !fn( thing );\n        };\n    };\n\n    /** hide\n     * $at( point ) -> Function\n     * - point (Vectorish): The point to check\n     * \n     * Get a test function to match any body who's aabb intersects point\n     **/\n    var $at = function $at( point ){\n        point = new Physics.vector( point );\n        return function( body ){\n            var aabb = body.aabb();\n            return Physics.aabb.contains( aabb, point );\n        };\n    };\n\n    /** hide\n     * $and( first ) -> Function\n     * - first (Function): First function node. `first.next` should have the next function, and so on.\n     * \n     * Get an AND test function.\n     **/\n    var $and = function $and( first ){\n        return first.next ? function( thing ){\n            var fn = first;\n            while ( fn ){\n\n                if ( !fn( thing ) ){\n                    return false;\n                }\n                fn = fn.next;\n            }\n            return true;\n        } : first;\n    };\n\n    /** hide\n     * $or( first ) -> Function\n     * - first (Function): First function node. `first.next` should have the next function, and so on.\n     * \n     * Get an OR test function.\n     **/\n    var $or = function $or( first ){\n        return first.next ? function( thing ){\n            var fn = first;\n            while ( fn ){\n\n                if ( fn( thing ) ){\n                    return true;\n                }\n                fn = fn.next;\n            }\n            return false;\n        } : first;\n    };\n\n    // operation hash\n    var operations = {\n        // $and and $or are separate\n        $eq: $eq\n        ,$ne: $ne\n        ,$in: $in\n        ,$nin: $nin\n        ,$at: $at\n    };\n\n    /** related to: Physics.world#find\n     * Physics.query( rules ) -> Function\n     * - rules (Object): The mongodb-like search rules. (See description).\n     * + (Function): The test function\n     * \n     * Creates a function that can be used to perform tests on objects.\n     *\n     * The test function will return a [[Boolean]]; `true` if the object matches the tests.\n     *\n     * Query rules are mongodb-like. You can specify a hash of values to match like this:\n     *\n     * ```javascript\n     * {\n     *     foo: 'bar',\n     *     baz: 2,\n     *     some: {\n     *         nested: 'value'\n     *     }\n     * }\n     * ```\n     *\n     * And they will all need to match (it's an AND rule).\n     *\n     * You can also use operators for more versatility. The operators you can use include:\n     *\n     * - $eq: Test if some property is equal to a value (this is done by default, and is thus redundant)\n     * - $ne: Test if some property is _NOT_ equal to a value\n     * - $in: Test if some value (or array of values) is one of the specified array of values\n     * - $nin: Test if some value (or array of values) is _NOT_ one of the specified array of values\n     * - $at: Test if a body's [[Physics.aabb]] includes specified point. It's a primative hit-test.\n     * \n     * Example:\n     *\n     * ```javascript\n     * var wheelsArray = [];\n     * \n     * var queryFn = Physics.query({\n     *     name: 'circle', // only circles\n     *     $nin: wheelsArray, // not in the wheelsArray\n     *     labels: { $in: [ 'player', 'monster' ] } // that have player OR monster labels\n     * });\n     *\n     * var obj = {\n     *     name: 'circle',\n     *     labels: [ 'round' ]\n     * };\n     *\n     * queryFn( obj ); // -> false\n     * // give it a player tag\n     * obj.labels.push('player');\n     * queryFn( obj ); // -> true\n     * // put it inside the wheelsArray\n     * wheelsArray.push( obj );\n     * queryFn( obj ); // -> false\n     * ```\n     **/\n    var Query = function Query( rules, /* internal use */ $op ){\n\n        var op\n            ,l\n            ,rule\n            ,first\n            ,list\n            ,fn\n            ;\n\n        if ( $op ){\n            \n            // parse operation choice\n            if ( $op === '$or' || $op === '$and' ){\n\n                // expect a rules array\n                for ( op = 0, l = rules.length; op < l; ++op ){\n                    \n                    fn = Query( rules[ op ] );\n                    // if first hasn't been set yet, set it and start the list there\n                    // otherwise set the next node of the list\n                    list = list ? list.next = fn : first = fn;\n                }\n\n                return ($op === '$or') ? $or( first ) : $and( first );\n            } else if ( op = operations[ $op ] ){\n\n                return op( rules );\n\n            } else {\n                // does not compute...\n                throw 'Unknown query operation: ' + $op;\n            }\n        }\n\n        // loop through rules\n        for ( op in rules ){\n            rule = rules[ op ];\n   \n            if ( op[0] === '$' ){\n                // it's an operation rule\n                fn = Query( rule, op );\n                \n            } else if ( Physics.util.isPlainObject( rule ) ) {\n                // it's an object so parse subrules\n                fn = wrapRule( Query( rule ), op );\n            } else {\n                // simple equality rule\n                fn = $eq( rule, op );\n            }\n\n            // if first hasn't been set yet, set it and start the list there\n            // otherwise set the next node of the list\n            list = list ? list.next = fn : first = fn;\n        }\n\n        // return the rules test\n        return $and( first || fnTrue );\n    };\n\n    Physics.query = Query;\n\n})(this);\n\n\n// ---\n// inside: src/core/behavior.js\n\n(function(){\n\n    var defaults = {\n        priority: 0\n    };\n\n    /** related to: Physics.util.decorator\n     * Physics.behavior( name[, options] ) -> Behavior\n     * - name (String): The name of the behavior to create\n     * - options (Object): The configuration for that behavior ( depends on behavior ).\n       Available options and defaults:\n       \n       ```javascript\n        {\n           priority: 0 // the priority of this body\n        }\n       ```\n     *\n     * Factory function for creating Behaviors.\n     *\n     * Visit [the PhysicsJS wiki on Behaviors](https://github.com/wellcaffeinated/PhysicsJS/wiki/Behaviors)\n     * for usage documentation.\n     **/\n    Physics.behavior = Decorator('behavior', {\n\n        /** belongs to: Physics.behavior\n         * class Behavior\n         *\n         * The base class for behaviors created by [[Physics.behavior]] factory function.\n         **/\n\n        /** internal\n         * Behavior#init( options )\n         * - options (Object): The configuration options passed by the factory\n         * \n         * Initialization. Internal use.\n         **/\n        init: function( options ){\n            \n            /** related to: Physics.util.options\n             * Behavior#options( options ) -> Object\n             * - options (Object): The options to set as an object\n             * + (Object): The options\n             * \n             * Set options on this instance. \n             * \n             * Access options directly from the options object.\n             * \n             * Example:\n             *\n             * ```javascript\n             * this.options.someOption;\n             * ```\n             * \n             **/\n            this.options = Physics.util.options( defaults );\n            this.options( options );\n        },\n\n        /**\n         * Behavior#applyTo( arr ) -> this\n         * - arr (Array): Array of bodies to apply this behavior to. Specify `true` for all objects in world.\n         * \n         * Apply the behavior to a group of bodies.\n         **/\n        applyTo: function( arr ){\n\n            if ( arr === true ){\n                this._targets = null;\n            } else {\n                this._targets = Physics.util.uniq( arr );\n            }\n            return this;\n        },\n\n        /**\n         * Behavior#getTargets() -> Array\n         * + (Array): The array of bodies (by reference!) this behavior is applied to.\n         * \n         * Get the array of bodies (by reference!) this behavior is applied to.\n         **/\n        getTargets: function(){\n            \n            return this._targets || ( this._world ? this._world._bodies : [] );\n        },\n\n        /**\n         * Behavior#setWorld( world ) -> this\n         * - world (Object): The world (or null)\n         *\n         * Set which world to apply to.\n         *\n         * Usually this is called internally. Shouldn't be a need to call this yourself usually.\n         **/\n        setWorld: function( world ){\n\n            if ( this.disconnect && this._world ){\n                this.disconnect( this._world );\n            }\n\n            this._world = world;\n\n            if ( this.connect && world ){\n                this.connect( world );\n            }\n\n            return this;\n        },\n\n        /**\n         * Behavior#connect( world )\n         * - world (Physics.world): The world to connect to\n         * \n         * Connect to a world.\n         *\n         * Extend this when creating behaviors if you need to specify pubsub management.\n         * Automatically called when added to world by the [[Behavior#setWorld]] method.\n         **/\n        connect: function( world ){\n\n            if (this.behave){\n                world.on('integrate:positions', this.behave, this, this.options.priority);\n            }\n        },\n\n        /**\n         * Behavior#disconnect( world )\n         * - world (Physics.world): The world to disconnect from\n         * \n         * Disconnect from a world.\n         *\n         * Extend this when creating behaviors if you need to specify pubsub management.\n         * Automatically called when added to world by the [[Behavior#setWorld]] method.\n         **/\n        disconnect: function( world ){\n\n            if (this.behave){\n                world.off('integrate:positions', this.behave, this);\n            }\n        },\n\n        /**\n         * Behavior#behave( data )\n         * - data (Object): The pubsub `integrate:positions` event data\n         * \n         * Default method run on every world integration.\n         *\n         * You _must_ extend this when creating a behavior,\n         * unless you extend the [[Behavior#connect]] and [[Behavior#disconnect]] methods.\n         **/\n        behave: null\n    });\n\n}());\n\n// ---\n// inside: src/core/body.js\n\n(function(){\n\n    var defaults = {\n\n        // is the body hidden (not to be rendered)?\n        hidden: false,\n        // is the body `dynamic`, `kinematic` or `static`?\n        // http://www.box2d.org/manual.html#_Toc258082973\n        treatment: 'dynamic',\n        // body mass\n        mass: 1.0,\n        // body restitution. How \"bouncy\" is it?\n        restitution: 1.0,\n        // what is its coefficient of friction with another surface with COF = 1?\n        cof: 0.8,\n        // what is the view object (mixed) that should be used when rendering?\n        view: null\n    };\n\n    var uidGen = 1;\n\n    var Pi2 = Math.PI * 2;\n    function cycleAngle( ang ){\n        return ((ang % Pi2) + Pi2) % Pi2;\n    }\n\n    /** related to: Physics.util.decorator\n     * Physics.body( name[, options] ) -> Body\n     * - name (String): The name of the body to create\n     * - options (Object): The configuration for that body ( depends on body ).\n       Available options and defaults:\n\n       ```javascript\n        {\n            // is the body hidden (not to be rendered)?\n            hidden: false,\n            // is the body `dynamic`, `kinematic` or `static`?\n            // http://www.box2d.org/manual.html#_Toc258082973\n            treatment: 'dynamic',\n            // body mass\n            mass: 1.0,\n            // body restitution. How \"bouncy\" is it?\n            restitution: 1.0,\n            // what is its coefficient of friction with another surface with COF = 1?\n            cof: 0.8,\n            // what is the view object (mixed) that should be used when rendering?\n            view: null,\n            // the vector offsetting the geometry from its center of mass\n            offset: Physics.vector(0,0)\n        }\n       ```\n     *\n     * Factory function for creating Bodies.\n     *\n     * Visit [the PhysicsJS wiki on Bodies](https://github.com/wellcaffeinated/PhysicsJS/wiki/Bodies)\n     * for usage documentation.\n     **/\n    Physics.body = Decorator('body', {\n\n        /** belongs to: Physics.body\n         * class Body\n         *\n         * The base class for bodies created by [[Physics.body]] factory function.\n         **/\n\n        /** internal\n         * Body#init( options )\n         * - options (Object): The configuration options passed by the factory\n         *\n         * Initialization. Internal use.\n         **/\n        init: function( options ){\n\n            var self = this;\n            var vector = Physics.vector;\n\n            /** related to: Physics.util.options\n             * Body#options( options ) -> Object\n             * - options (Object): The options to set as an object\n             * + (Object): The options\n             *\n             * Set options on this instance.\n             *\n             * Access options directly from the options object.\n             *\n             * Example:\n             *\n             * ```javascript\n             * this.options.someOption;\n             * ```\n             *\n             **/\n            // all options get copied onto the body.\n            this.options = Physics.util.options( defaults, this );\n            this.options.onChange(function( opts ){\n                self.offset = new vector( opts.offset );\n            });\n            this.options( options );\n\n            /**\n             * Body#state\n             *\n             * The physical state container.\n             *\n             * - ``this.state.pos`` ([[Physics.vector]]) The position vector.\n             * - ``this.state.vel`` ([[Physics.vector]]) The velocity vector.\n             * - ``this.state.acc`` ([[Physics.vector]]) The acceleration vector.\n             * - ``this.state.angular.pos`` ([[Number]]) The angular position (in radians, positive is clockwise starting along the x axis)\n             * - ``this.state.angular.vel`` ([[Number]]) The angular velocity\n             * - ``this.state.angular.acc`` ([[Number]]) The angular acceleration\n             *\n             * Properties from the previous timestep are stored in:\n             * ```javascript\n             * this.state.old; // .pos, .vel, ...\n             * ```\n             **/\n            this.state = {\n                pos: new vector( this.x, this.y ),\n                vel: new vector( this.vx, this.vy ),\n                acc: new vector(),\n                angular: {\n                    pos: this.angle || 0.0,\n                    vel: this.angularVelocity || 0.0,\n                    acc: 0.0\n                },\n                old: {\n                    pos: new vector(),\n                    vel: new vector(),\n                    acc: new vector(),\n                    angular: {\n                        pos: 0.0,\n                        vel: 0.0,\n                        acc: 0.0\n                    }\n                }\n            };\n\n            // private storage for sleeping\n            this._sleepAngPosMean = 0;\n            this._sleepAngPosVariance = 0;\n            this._sleepPosMean = new vector();\n            this._sleepPosVariance = new vector();\n            this._sleepMeanK = 0;\n\n            // cleanup\n            delete this.x;\n            delete this.y;\n            delete this.vx;\n            delete this.vy;\n            delete this.angle;\n            delete this.angularVelocity;\n\n            if (this.mass === 0){\n                throw \"Error: Bodies must have non-zero mass\";\n            }\n\n            /**\n             * Body#uid = Number\n             *\n             * The unique id for the body\n             **/\n            this.uid = uidGen++;\n\n            /** related to: Physics.geometry\n             * Body#geometry\n             *\n             * The geometry for this body.\n             *\n             * By default it is a `point` geometry which gets overridden.\n             **/\n            this.geometry = Physics.geometry('point');\n\n            /**\n             * Body#mass = 1.0\n             *\n             * The mass.\n             **/\n\n            /**\n             * Body#offset\n             *\n             * The vector offsetting the body's shape from its center of mass.\n             **/\n\n             /**\n              * Body#restitution = 1.0\n              *\n              * The restitution.\n              *\n              * This is the \"bounciness\" of the body.\n              * It's a number between `0` and `1`.\n              *\n              * A restitution of 1 is the bounciest.\n              *\n              * A restitution of 0 is not bouncy.\n              *\n              * When colliding the restitutions of bodies are\n              * multiplied together to get the restitution between two\n              * bodies.\n              *\n              **/\n\n              /**\n               * Body#cof = 0.8\n               *\n               * The coefficient of friction of the body.\n               *\n               * It's how much \"slide\" it has during collisions.\n               *\n               * A `cof` of `0` will really slidy.\n               *\n               * A `cof` of `1` has no slide.\n               *\n               * This is a very simplistic implementation at the moment.\n               * What would be better is to have both static and kinetic\n               * friction. But that's not done yet.\n               **/\n\n               /**\n                * Body#treatment = String\n                *\n                * How the body is treated by the simulation.\n                *\n                * The body can be `dynamic`, `kinematic` or `static` as\n                * described by the [analogous box2d docs](http://www.box2d.org/manual.html#_Toc258082973).\n                *\n                * * _dynamic_ bodies are treated \"normally\". They are integrated, and collide, and all that.\n                * * _kinematic_ bodies are bodies that move at a specified velocity. Other bodies collide with them, but they don't bounce off of other bodies.\n                * * _static_ bodies just stand still. They are like obstacles.\n                **/\n\n                /**\n                 * Body#hidden = false\n                 *\n                 * Determines whether the body should be hidden by the renderer.\n                 **/\n\n                /** related to: Physics.renderer\n                 * Body#view = it_depends\n                 *\n                 * Storage for use by the renderer.\n                 *\n                 * The type of renderer will put different things in the view property.\n                 * Basically, this is how the body \"looks\". It could be a HTMLElement, or\n                 * an Image, etc...\n                 *\n                 * If your body changes appearance (shape), you should modify this somehow\n                 * otherwise the renderer will keep using this same view. If you're letting\n                 * the renderer create the view for you, just set this to `undefined` if the\n                 * body gets modified in shape during the simulation.\n                 **/\n\n                /** related to: Physics.renderer\n                 * Body#styles\n                 *\n                 * The styles the renderer should use for creating the view.\n                 *\n                 * The styles depend on the renderer. See [[Renderer#createView]] for style options.\n                 **/\n        },\n\n        /**\n         * Body#sleep( [dt] ) -> Boolean\n         * - dt (Number): Time to advance the idle time\n         * - dt (Boolean): If `true`, the body will be forced to sleep. If `false`, the body will be forced to awake.\n         *\n         * Get and/or set whether the body is asleep.\n         *\n         * If called with a time (in ms), the time will be added to the idle time and sleep conditions will be checked.\n         **/\n        sleep: function( dt ){\n\n            if ( dt === true ){\n                // force sleep\n                this.asleep = true;\n\n            } else if ( dt === false ){\n                // force wakup\n                this.asleep = false;\n                this._sleepMeanK = 0;\n                this._sleepAngPosMean = 0;\n                this._sleepAngPosVariance = 0;\n                this._sleepPosMean.zero();\n                this._sleepPosVariance.zero();\n                this.sleepIdleTime = 0;\n\n            } else if ( dt && !this.asleep ) {\n\n                this.sleepCheck( dt );\n            }\n\n            return this.asleep;\n        },\n\n        /**\n         * Body#sleepCheck( [dt] )\n         * - dt (Number): Time to advance the idle time\n         *\n         * Check if the body should be sleeping.\n         *\n         * Call with no arguments if some event could possibly wake up the body. This will force the body to recheck.\n         **/\n        sleepCheck: function( dt ){\n\n            var opts = this._world && this._world.options;\n\n            // if sleeping disabled. stop.\n            if ( this.sleepDisabled || (opts && opts.sleepDisabled) ){\n                return;\n            }\n\n            var limit\n                ,v\n                ,d\n                ,r\n                ,aabb\n                ,scratch = Physics.scratchpad()\n                ,diff = scratch.vector()\n                ,diff2 = scratch.vector()\n                ,kfac\n                ,stats\n                ;\n\n            dt = dt || 0;\n            aabb = this.geometry.aabb();\n            r = Math.max(aabb.hw, aabb.hh);\n\n            if ( this.asleep ){\n                // check velocity\n                v = this.state.vel.norm() + Math.abs(r * this.state.angular.vel);\n                limit = this.sleepSpeedLimit || (opts && opts.sleepSpeedLimit) || 0;\n\n                if ( v >= limit ){\n                    this.sleep( false );\n                    return scratch.done();\n                }\n            }\n\n            this._sleepMeanK++;\n            kfac = this._sleepMeanK > 1 ? 1/(this._sleepMeanK - 1) : 0;\n            Physics.statistics.pushRunningVectorAvg( this.state.pos, this._sleepMeanK, this._sleepPosMean, this._sleepPosVariance );\n            // we take the sin because that maps the discontinuous angle to a continuous value\n            // then the statistics calculations work better\n            stats = Physics.statistics.pushRunningAvg( Math.sin(this.state.angular.pos), this._sleepMeanK, this._sleepAngPosMean, this._sleepAngPosVariance );\n            this._sleepAngPosMean = stats[0];\n            this._sleepAngPosVariance = stats[1];\n            v = this._sleepPosVariance.norm() + Math.abs(r * Math.asin(stats[1]));\n            v *= kfac;\n            limit = this.sleepVarianceLimit || (opts && opts.sleepVarianceLimit) || 0;\n            // console.log(v, limit, kfac, this._sleepPosVariance.norm(), stats[1])\n            if ( v <= limit ){\n                // check idle time\n                limit = this.sleepTimeLimit || (opts && opts.sleepTimeLimit) || 0;\n                this.sleepIdleTime = (this.sleepIdleTime || 0) + dt;\n\n                if ( this.sleepIdleTime > limit ){\n                    this.asleep = true;\n                }\n            } else {\n                this.sleep( false );\n            }\n\n            scratch.done();\n        },\n\n        /**\n         * Body#setWorld( world ) -> this\n         * - world (Object): The world (or null)\n         *\n         * Set which world to apply to.\n         *\n         * Usually this is called internally. Shouldn't be a need to call this yourself usually.\n         **/\n        setWorld: function( world ){\n\n            if ( this.disconnect && this._world ){\n                this.disconnect( this._world );\n            }\n\n            this._world = world;\n\n            if ( this.connect && world ){\n                this.connect( world );\n            }\n\n            return this;\n        },\n\n        /**\n         * Body#accelerate( acc ) -> this\n         * - acc (Physics.vector): The acceleration vector\n         *\n         * Accelerate the body by adding supplied vector to its current acceleration\n         **/\n        accelerate: function( acc ){\n\n            if ( this.treatment === 'dynamic' ){\n                this.state.acc.vadd( acc );\n            }\n\n            return this;\n        },\n\n        /**\n         * Body#applyForce( force[, p] ) -> this\n         * - force (Vectorish): The force vector\n         * - p (Vectorish): The point vector from the COM at which to apply the force\n         *\n         * Apply a force at center of mass, or at point `p` relative to the center of mass\n         **/\n        applyForce: function( force, p ){\n\n            if ( this.treatment !== 'dynamic' ){\n                return this;\n            }\n\n            var scratch = Physics.scratchpad()\n                ,r = scratch.vector()\n                ,state\n                ;\n\n            // if no point at which to apply the force... apply at center of mass\n            if ( p && this.moi ){\n\n                // apply torques\n                state = this.state;\n                r.clone( p );\n                // r cross F\n                this.state.angular.acc -= r.cross( force ) / this.moi;\n            }\n\n            this.accelerate( r.clone( force ).mult( 1/this.mass ) );\n\n            scratch.done();\n            return this;\n        },\n\n        /** related to: Body#offset\n         * Body#getGlobalOffset( [out] ) -> Physics.vector\n         * - out (Physics.vector): A vector to use to put the result into. One is created if `out` isn't specified.\n         * + (Physics.vector): The offset in global coordinates\n         *\n         * Get the body offset vector (from the center of mass) for the body's shape in global coordinates.\n         **/\n        getGlobalOffset: function( out ){\n\n            out = out || new Physics.vector();\n            out.clone( this.offset ).rotate( this.state.angular.pos );\n            return out;\n        },\n\n        /** related to: Physics.aabb\n         * Body#aabb() -> Object\n         * + (Object): The aabb of this body\n         *\n         * Get the Axis aligned bounding box for the body in its current position and rotation\n         **/\n        aabb: function(){\n\n            var angle = this.state.angular.pos\n                ,scratch = Physics.scratchpad()\n                ,v = scratch.vector()\n                ,aabb = this.geometry.aabb( angle )\n                ;\n\n            this.getGlobalOffset( v );\n\n            aabb.x += this.state.pos._[0] + v._[0];\n            aabb.y += this.state.pos._[1] + v._[1];\n\n            return scratch.done( aabb );\n        },\n\n        /**\n         * Body#toBodyCoords( v ) -> Physics.vector\n         * - v (Physics.vector): The vector to transform\n         * + (Physics.vector): The transformed vector\n         *\n         * Transform a vector into coordinates relative to this body.\n         **/\n        toBodyCoords: function( v ){\n            return v.vsub( this.state.pos ).rotate( -this.state.angular.pos );\n        },\n\n        /**\n          * Body#toWorldCoords( v ) -> Physics.vector\n          * - v (Physics.vector): The vector to transform\n          * + (Physics.vector): The transformed vector\n          *\n          * Transform a vector from body coordinates into world coordinates.\n          **/\n        toWorldCoords: function( v ){\n            return v.rotate( this.state.angular.pos ).vadd( this.state.pos );\n        },\n\n        /**\n         * Body#recalc() -> this\n         *\n         * Recalculate properties.\n         *\n         * Intended to be overridden by subclasses. Call when body physical properties are changed.\n         **/\n        recalc: function(){\n            // override to recalculate properties\n            return this;\n        }\n    });\n\n    /**\n     * Body.getCOM( bodies[, com] ) -> Physics.vector\n     * - bodies (Array): The list of bodies\n     * - com (Physics.vector): The vector to put result into. A new vector will be created if not provided.\n     * + (Physics.vector): The center of mass position\n     *\n     * Get center of mass position from list of bodies.\n     **/\n    Physics.body.getCOM = function( bodies, com ){\n        // @TODO add a test for this fn\n        var b\n            ,pos\n            ,i\n            ,l = bodies && bodies.length\n            ,M = 0\n            ;\n\n        com = com || new Physics.vector();\n\n        if ( !l ){\n            return com.zero();\n        }\n\n        if ( l === 1 ){\n            return com.clone( bodies[0].state.pos );\n        }\n\n        com.zero();\n\n        for ( i = 0; i < l; i++ ){\n            b = bodies[ i ];\n            pos = b.state.pos;\n            com.add( pos._[0] * b.mass, pos._[1] * b.mass );\n            M += b.mass;\n        }\n\n        com.mult( 1 / M );\n\n        return com;\n    };\n\n}());\n\n\n// ---\n// inside: src/core/geometry.js\n\n(function(){\n    /** related to: Physics.util.decorator\n     * Physics.geometry( name[, options] ) -> Geometry\n     * - name (String): The name of the geometry to create\n     * - options (Object): The configuration for that geometry ( depends on geometry ).\n     *\n     * Factory function for creating Geometries.\n     *\n     * Visit [the PhysicsJS wiki on Geometries](https://github.com/wellcaffeinated/PhysicsJS/wiki/Geometries)\n     * for usage documentation.\n     **/\n    Physics.geometry = Decorator('geometry', {\n\n        /** belongs to: Physics.geometry\n         * class Geometry\n         *\n         * The base class for geometries created by [[Physics.geometry]] factory function.\n         **/\n\n        /** internal\n         * Geometry#init( options )\n         * - options (Object): The configuration options passed by the factory\n         * \n         * Initialization. Internal use.\n         **/\n        init: function( options ){\n\n            /** related to: Physics.util.options\n             * Geometry#options( options ) -> Object\n             * - options (Object): The options to set as an object\n             * + (Object): The options\n             * \n             * Set options on this instance. \n             * \n             * Access options directly from the options object.\n             * \n             * Example:\n             *\n             * ```javascript\n             * this.options.someOption;\n             * ```\n             * \n             **/\n            this.options = Physics.util.options();\n            this.options( options );\n\n            this._aabb = new Physics.aabb();\n        },\n        \n        /** related to: Physics.aabb\n         * Geometry#aabb( angle ) -> Object\n         * - angle (Number): The angle to rotate the geometry\n         * + (Object): Bounding box values\n         * \n         * Get axis-aligned bounding box for this object (rotated by angle if specified).\n         **/\n        aabb: function( angle ){\n\n            return Physics.aabb.clone(this._aabb);\n        },\n\n        /**\n         * Geometry#getFarthestHullPoint( dir[, result] ) -> Physics.vector\n         * - dir (Physics.vector): Direction to look\n         * - result (Physics.vector): A vector to write result to. Speeds up calculations.\n         * + (Physics.vector): The farthest hull point in local coordinates\n         * \n         * Get farthest point on the hull of this geometry\n         * along the direction vector `dir`\n         * returns local coordinates. Replaces result if provided.\n         *\n         * Assume all coordinates are relative to the geometry \n         * centroid (IE: in the body frame).\n         * \n         * This should take a direction vector then it should\n         * calculate the location (in that frame of reference)\n         * of the point on the perimeter (hull) if you traveled\n         * in a straight line from the centroid in the provided\n         * direction. The result should be returned/set just like\n         * it is in the other geometries.\n         **/\n        getFarthestHullPoint: function( dir, result ){\n\n            result = result || new Physics.vector();\n\n            // not implemented.\n            return result.set( 0, 0 );\n        },\n\n        /** related to: Geometry#getFarthestHullPoint\n         * Geometry#getFarthestCorePoint( dir[, result] ) -> Physics.vector\n         * - dir (Physics.vector): Direction to look\n         * - result (Physics.vector): A vector to write result to. Speeds up calculations.\n         * + (Physics.vector): The farthest hull point in local coordinates\n         * \n         * Get farthest point on the core shape of this geometry\n         * along the direction vector `dir`\n         * returns local coordinates. Replaces result if provided.\n         *\n         * This does almost the same thing as [[Geometry#getFarthestHullPoint]]\n         * but shrinks the shape by subtracting \"margin\" from it.\n         * Return the position of the point on the \"core\" shape.\n         **/\n        getFarthestCorePoint: function( dir, result, margin ){\n\n            result = result || new Physics.vector();\n\n            // not implemented.\n            return result.set( 0, 0 );\n        }\n    });\n\n}());\n\n// ---\n// inside: src/core/geometry-helpers.js\n\n/*\n * Geometry helper functions\n */\n\n/**\n * Physics.geometry.regularPolygonVertices( sides, radius ) -> Array\n * - sides (Number): Number of sides the polygon has\n * - radius (Number): Size from center to a vertex\n * + (Array): A list of [[Vectorish]] objects representing the vertices\n *\n * Generate a list of vertices for a regular polygon of any number of sides.\n **/\nPhysics.geometry.regularPolygonVertices = function( sides, radius ){\n    var verts = []\n        ,angle = Math.PI * 2 / sides\n        ,a = 0\n        ,i\n        ;\n\n    for ( i = 0; i < sides; i++ ){\n        verts.push({\n            x: radius * Math.cos( a )\n            ,y: radius * Math.sin( a )\n        });\n\n        a += angle;\n    }\n\n    return verts;\n};\n\n/**\n * Physics.geometry.isPolygonConvex( hull ) -> Boolean\n * - hull (Array): Array of ([[Vectorish]]) vertices\n * + (Boolean): `true` if the polygon is convex. `false` otherwise.\n *\n * Determine if polygon hull is convex\n **/\nPhysics.geometry.isPolygonConvex = function( hull ){\n\n    var scratch = Physics.scratchpad()\n        ,prev = scratch.vector()\n        ,next = scratch.vector()\n        ,tmp = scratch.vector()\n        ,ret = true\n        ,sign = false\n        ,l = hull.length\n        ;\n\n    if ( !hull || !l ){\n        return false;\n    }\n\n    if ( l < 3 ){\n        // it must be a point or a line...\n        // which are convex\n        scratch.done();\n        return ret;\n    }\n\n    prev.clone( hull[ 0 ] ).vsub( tmp.clone( hull[ l - 1 ] ) );\n\n    // loop over the edges of the hull and construct vectors of the current\n    // edge and retain the last edge\n    // add two to the length to do a full cycle\n    for ( var i = 1; i <= l; ++i ){\n\n        next.clone( hull[ i % l ] ).vsub( tmp.clone( hull[ (i - 1) % l ] ) );\n\n        if ( sign === false ){\n\n            // first check the sign of the first cross product\n            sign = prev.cross( next );\n\n        } else if ( (sign > 0) ^ (prev.cross( next ) > 0) ){\n\n            // if the cross products are different signs it's not convex\n            ret = false;\n            break;\n        }\n\n        // remember the last edge\n        next.swap( prev );\n    }\n\n    scratch.done();\n    return ret;\n};\n\n/**\n * Physics.geometry.getPolygonMOI( hull ) -> Number\n * - hull (Array): Array of ([[Vectorish]]) vertices\n * + (Number): The polygon's moment of inertia\n *\n * Gets the moment of inertia of a convex polygon\n *\n * See [List of moments of inertia](http://en.wikipedia.org/wiki/List_of_moments_of_inertia)\n * for more information.\n *\n * _Note_: we make the following assumpations:\n * * mass is unitary (== 1)\n * * axis of rotation is the origin\n **/\nPhysics.geometry.getPolygonMOI = function( hull ){\n\n    var scratch = Physics.scratchpad()\n        ,prev = scratch.vector()\n        ,next = scratch.vector()\n        ,num = 0\n        ,denom = 0\n        ,tmp\n        ,l = hull.length\n        ;\n\n    if ( l < 2 ){\n        // it must be a point\n        // moi = 0\n        scratch.done();\n        return 0;\n    }\n\n    if ( l === 2 ){\n        // it's a line\n        // get length squared\n        tmp = next.clone( hull[ 1 ] ).distSq( prev.clone( hull[ 0 ] ) );\n        scratch.done();\n        return tmp / 12;\n    }\n\n    prev.clone( hull[ 0 ] );\n\n    for ( var i = 1; i < l; ++i ){\n\n        next.clone( hull[ i ] );\n\n        tmp = Math.abs( next.cross( prev ) );\n        num += tmp * ( next.normSq() + next.dot( prev ) + prev.normSq() );\n        denom += tmp;\n\n        prev.swap( next );\n    }\n\n    scratch.done();\n    return num / ( 6 * denom );\n};\n\n/**\n * Physics.geometry.isPointInPolygon( pt, hull ) -> Boolean\n * - pt (Vectorish): The point to test\n * - hull (Array): Array of ([[Vectorish]]) vertices\n * + (Boolean): `true` if point `pt` is inside the polygon\n *\n * Check if point is inside polygon hull.\n **/\nPhysics.geometry.isPointInPolygon = function( pt, hull ){\n\n    var scratch = Physics.scratchpad()\n        ,point = scratch.vector().clone( pt )\n        ,prev = scratch.vector()\n        ,next = scratch.vector()\n        ,ang = 0\n        ,l = hull.length\n        ;\n\n    if ( l < 2 ){\n        // it's a point...\n        ang = point.equals( prev.clone( hull[ 0 ] ));\n        scratch.done();\n        return ang;\n    }\n\n    if ( l === 2 ){\n        // it's a line\n        ang = point.angle( prev.clone( hull[ 0 ] ));\n        ang += point.angle( prev.clone( hull[ 1 ] ));\n        scratch.done();\n        return ( Math.abs(ang) === Math.PI );\n    }\n\n    prev.clone( hull[ 0 ] ).vsub( point );\n\n    // calculate the sum of angles between vector pairs\n    // from point to vertices\n    for ( var i = 1; i <= l; ++i ){\n\n        next.clone( hull[ i % l ] ).vsub( point );\n        ang += next.angle( prev );\n        prev.swap( next );\n    }\n\n    scratch.done();\n    return ( Math.abs(ang) > 1e-6 );\n};\n\n/**\n * Physics.geometry.getPolygonArea( hull ) -> Number\n * - hull (Array): Array of ([[Vectorish]]) vertices\n * + (Number): The area (positive for clockwise ordering)\n *\n * Get the signed area of the polygon.\n **/\nPhysics.geometry.getPolygonArea = function getPolygonArea( hull ){\n\n    var scratch = Physics.scratchpad()\n        ,prev = scratch.vector()\n        ,next = scratch.vector()\n        ,ret = 0\n        ,l = hull.length\n        ;\n\n    if ( l < 3 ){\n        // it must be a point or a line\n        // area = 0\n        scratch.done();\n        return 0;\n    }\n\n    prev.clone( hull[ l - 1 ] );\n\n    for ( var i = 0; i < l; ++i ){\n\n        next.clone( hull[ i ] );\n\n        ret += prev.cross( next );\n\n        prev.swap( next );\n    }\n\n    scratch.done();\n    return ret / 2;\n};\n\n/**\n * Physics.geometry.getPolygonCentroid( hull ) -> Physics.vector\n * - hull (Array): Array of ([[Vectorish]]) vertices\n * + (Physics.vector): The centroid\n *\n * Get the coordinates of the centroid.\n **/\nPhysics.geometry.getPolygonCentroid = function getPolygonCentroid( hull ){\n\n    var scratch = Physics.scratchpad()\n        ,prev = scratch.vector()\n        ,next = scratch.vector()\n        ,ret = new Physics.vector()\n        ,tmp\n        ,l = hull.length\n        ;\n\n    if ( l < 2 ){\n        // it must be a point\n        scratch.done();\n        return new Physics.vector( hull[0] );\n    }\n\n    if ( l === 2 ){\n        // it's a line\n        // get the midpoint\n        scratch.done();\n        return new Physics.vector((hull[ 1 ].x + hull[ 0 ].x)/2, (hull[ 1 ].y + hull[ 0 ].y)/2 );\n    }\n\n    prev.clone( hull[ l - 1 ] );\n\n    for ( var i = 0; i < l; ++i ){\n\n        next.clone( hull[ i ] );\n\n        tmp = prev.cross( next );\n        prev.vadd( next ).mult( tmp );\n        ret.vadd( prev );\n\n        prev.swap( next );\n    }\n\n    tmp = 1 / (6 * Physics.geometry.getPolygonArea( hull ));\n\n    scratch.done();\n    return ret.mult( tmp );\n};\n\n/**\n * Physics.geometry.nearestPointOnLine( pt, linePt1, linePt2 ) -> Physics.vector\n * - pt (Vectorish): The point\n * - linePt1 (Vectorish): The first endpoint of the line\n * - linePt2 (Vectorish): The second endpoint of the line\n * + (Vector): The closest point\n *\n * Get the closest point on a discrete line to specified point.\n **/\nPhysics.geometry.nearestPointOnLine = function nearestPointOnLine( pt, linePt1, linePt2 ){\n\n    var scratch = Physics.scratchpad()\n        ,p = scratch.vector().clone( pt )\n        ,A = scratch.vector().clone( linePt1 ).vsub( p )\n        ,L = scratch.vector().clone( linePt2 ).vsub( p ).vsub( A )\n        ,lambdaB\n        ,lambdaA\n        ;\n\n    if ( L.equals(Physics.vector.zero) ){\n        // oh.. it's a zero vector. So A and B are both the closest.\n        // just use one of them\n        scratch.done();\n        return new Physics.vector( linePt1 );\n    }\n\n    lambdaB = - L.dot( A ) / L.normSq();\n    lambdaA = 1 - lambdaB;\n\n    if ( lambdaA <= 0 ){\n        // woops.. that means the closest simplex point\n        // isn't on the line it's point B itself\n        scratch.done();\n        return new Physics.vector( linePt2 );\n    } else if ( lambdaB <= 0 ){\n        // vice versa\n        scratch.done();\n        return new Physics.vector( linePt1 );\n    }\n\n    // guess we'd better do the math now...\n    p = new Physics.vector( linePt2 ).mult( lambdaB ).vadd( A.clone( linePt1 ).mult( lambdaA ) );\n    scratch.done();\n    return p;\n};\n\n\n// ---\n// inside: src/core/integrator.js\n\n(function(){\n\n    var defaults = {\n\n        // drag applied during integration\n        // 0 means vacuum\n        // 0.9 means molasses\n        drag: 0\n    };\n\n    /** related to: Physics.util.decorator\n     * Physics.integrator( name[, options] ) -> Integrator\n     * - name (String): The name of the integrator to create\n     * - options (Object): The configuration for that integrator ( depends on integrator ).\n       Available options and defaults:\n\n       ```javascript\n        {\n            // drag applied during integration\n            // 0 means vacuum\n            // 0.9 means molasses\n            drag: 0\n        }\n       ```\n     *\n     * Factory function for creating Integrators.\n     *\n     * Visit [the PhysicsJS wiki on Integrators](https://github.com/wellcaffeinated/PhysicsJS/wiki/Integrators)\n     * for usage documentation.\n     **/\n    Physics.integrator = Decorator('integrator', {\n\n        /** belongs to: Physics.integrator\n         * class Integrator\n         *\n         * The base class for integrators created by [[Physics.integrator]] factory function.\n         **/\n\n        /** internal\n         * Integrator#init( options )\n         * - options (Object): The configuration options passed by the factory\n         *\n         * Initialization. Internal use.\n         **/\n        init: function( options ){\n\n            /** related to: Physics.util.options\n             * Integrator#options( options ) -> Object\n             * - options (Object): The options to set as an object\n             * + (Object): The options\n             *\n             * Set options on this instance.\n             *\n             * Access options directly from the options object.\n             *\n             * Example:\n             *\n             * ```javascript\n             * this.options.someOption;\n             * ```\n             *\n             **/\n            this.options = Physics.util.options( defaults );\n            this.options( options );\n        },\n\n        /**\n         * Integrator#setWorld( world ) -> this\n         * - world (Object): The world (or null)\n         *\n         * Set which world to apply to.\n         *\n         * Usually this is called internally. Shouldn't be a need to call this yourself usually.\n         **/\n        setWorld: function( world ){\n\n            if ( this.disconnect && this._world ){\n                this.disconnect( this._world );\n            }\n\n            this._world = world;\n\n            if ( this.connect && world ){\n                this.connect( world );\n            }\n\n            return this;\n        },\n\n        /**\n         * Integrator#integrate( bodies, dt ) -> this\n         * - bodies (Array): List of bodies to integrate\n         * - dt (Number): Timestep size\n         *\n         * Integrate bodies by timestep.\n         *\n         * Will emit `integrate:velocities` and `integrate:positions`\n         * events on the world.\n         **/\n        integrate: function( bodies, dt ){\n\n            var world = this._world;\n\n            this.integrateVelocities( bodies, dt );\n\n            if ( world ){\n                world.emit('integrate:velocities', {\n                    bodies: bodies,\n                    dt: dt\n                });\n            }\n\n            this.integratePositions( bodies, dt );\n\n            if ( world ){\n                world.emit('integrate:positions', {\n                    bodies: bodies,\n                    dt: dt\n                });\n            }\n\n            return this;\n        },\n\n        /**\n         * Integrator#connect( world )\n         * - world (Physics.world): The world to connect to\n         *\n         * Connect to a world.\n         *\n         * Extend this when creating integrators if you need to specify pubsub management.\n         * Automatically called when added to world by the [[Integrator#setWorld]] method.\n         **/\n        connect: null,\n\n        /**\n         * Integrator#disconnect( world )\n         * - world (Physics.world): The world to disconnect from\n         *\n         * Disconnect from a world.\n         *\n         * Extend this when creating integrators if you need to specify pubsub management.\n         * Automatically called when added to world by the [[Integrator#setWorld]] method.\n         **/\n        disconnect: null,\n\n        /**\n         * Integrator#integrateVelocities( bodies, dt )\n         * - bodies (Array): List of bodies to integrate\n         * - dt (Number): Timestep size\n         *\n         * Just integrate the velocities.\n         *\n         * Should be overridden when creating integrators.\n         **/\n        integrateVelocities: function( bodies, dt ){\n\n            throw 'The integrator.integrateVelocities() method must be overriden';\n        },\n\n        /**\n         * Integrator#integratePositions( bodies, dt )\n         * - bodies (Array): List of bodies to integrate\n         * - dt (Number): Timestep size\n         *\n         * Just integrate the positions.\n         *\n         * Called after [[Integrator#integrateVelocities]].\n         *\n         * Should be overridden when creating integrators.\n         **/\n        integratePositions: function( bodies, dt ){\n\n            throw 'The integrator.integratePositions() method must be overriden';\n        }\n    });\n\n}());\n\n\n// ---\n// inside: src/core/renderer.js\n\n(function(){\n\n    var defaults = {\n        // draw meta data (fps, steps, etc)\n        meta: false,\n        // refresh rate of meta info\n        metaRefresh: 200,\n\n        // width of viewport\n        width: 600,\n        // height of viewport\n        height: 600,\n        // automatically resize the renderer\n        autoResize: true\n    };\n\n    /** related to: Physics.util.decorator\n     * Physics.renderer( name[, options] ) -> Renderer\n     * - name (String): The name of the renderer to create\n     * - options (Object): The configuration for that renderer ( depends on renderer ).\n       Available options and defaults:\n\n       ```javascript\n        {\n            // draw meta data (fps, steps, etc)\n            meta: false,\n            // refresh rate of meta info\n            metaRefresh: 200,\n\n            // width of viewport\n            width: 600,\n            // height of viewport\n            height: 600\n            // automatically resize the renderer\n            autoResize: true\n        }\n       ```\n     *\n     * Factory function for creating Renderers.\n     *\n     * Visit [the PhysicsJS wiki on Renderers](https://github.com/wellcaffeinated/PhysicsJS/wiki/Renderers)\n     * for usage documentation.\n     **/\n    Physics.renderer = Decorator('renderer', {\n\n        /** belongs to: Physics.renderer\n         * class Renderer\n         *\n         * The base class for renderers created by [[Physics.renderer]] factory function.\n         **/\n\n        /** internal\n         * Renderer#init( options )\n         * - options (Object): The configuration options passed by the factory\n         *\n         * Initialization. Internal use.\n         **/\n        init: function( options ){\n\n            var self = this\n                ,el = typeof options.el === 'string' ? document.getElementById(options.el) : options.el\n                ;\n\n            this.options = Physics.util.options(defaults);\n            this.options( options );\n\n            this.el = el ? el : document.body;\n            this.container = el && el.parentNode ? el.parentNode : document.body;\n            this.drawMeta = Physics.util.throttle( Physics.util.bind(this.drawMeta, this), this.options.metaRefresh );\n\n            window.addEventListener('resize', Physics.util.throttle(function(){\n                if ( self.options.autoResize ){\n                    self.resize();\n                }\n            }), 100);\n        },\n\n        /**\n         * Renderer#resize( [width, height] ) -> this\n         * - width (Number): The width in px\n         * - height (Number): The height in px\n         *\n         * Set the dimensions of the renderer.\n         *\n         * If no dimensions are specified it will auto resize.\n         **/\n        resize: function( width, height ){\n\n            if ( width === undefined && height === undefined ){\n                width = this.container.offsetWidth;\n                height = this.container.offsetHeight;\n            }\n\n            this.width = width || 0;\n            this.height = height || 0;\n            // should be implemented in renderers\n        },\n\n        /**\n         * Renderer#setWorld( world ) -> this\n         * - world (Object): The world (or null)\n         *\n         * Set which world to apply to.\n         *\n         * Usually this is called internally. Shouldn't be a need to call this yourself usually.\n         **/\n        setWorld: function( world ){\n\n            if ( this.disconnect && this._world ){\n                this.disconnect( this._world );\n            }\n\n            this._world = world;\n\n            if ( this.connect && world ){\n                this.connect( world );\n            }\n\n            return this;\n        },\n\n        /**\n         * Renderer#render( bodies, meta ) -> this\n         * - bodies (Array): Array of bodies in the world (by reference!)\n         * - meta (Object): meta information\n         *\n         * Render the world bodies and meta. Called by world.render()\n         **/\n        render: function( bodies, meta ){\n\n            var body\n                ,view\n                ,pos\n                ;\n\n            if (this.beforeRender){\n\n                this.beforeRender();\n            }\n\n            this._world.emit('beforeRender', {\n                renderer: this,\n                bodies: bodies,\n                meta: meta\n            });\n\n            if (this.options.meta){\n                this.drawMeta( meta );\n            }\n\n            this._interpolateTime = meta.interpolateTime;\n\n            for ( var i = 0, l = bodies.length; i < l; ++i ){\n\n                body = bodies[ i ];\n                view = body.view || ( body.view = this.createView(body.geometry, body.styles) );\n\n                if ( !body.hidden ){\n                    this.drawBody( body, view );\n                }\n            }\n\n            return this;\n        },\n\n        /**\n         * Renderer#createView( geometry, styles ) -> Mixed\n         * - geometry (Geometry): geometry The geometry\n         * - styles (Object|String): The styles configuration\n         * + (Mixed): Whatever the renderer needs to render the body.\n         *\n         * Create a view for the specified geometry.\n         *\n         * The view is used to render the body. It is a cached version\n         * of the body that gets moved and rotated according to the simulation.\n         *\n         * The styles are used to modify the appearance of the view.\n         * They depend on the renderer.\n         *\n         * Override this when creating renderers.\n         **/\n        createView: function( geometry, styles ){\n\n            // example:\n            // var el = document.createElement('div');\n            // el.style.height = geometry.height + 'px';\n            // el.style.width = geometry.width + 'px';\n            // return el;\n            throw 'You must override the renderer.createView() method.';\n        },\n\n        /**\n         * Renderer#drawMeta( meta )\n         * - meta (Object): The meta data\n         *\n         * Draw the meta data.\n         *\n         * The meta data will look like this:\n         *\n         * ```javascript\n         * meta = {\n         *     fps: 60, // the frames per second\n         *     ipf: 4 // the number of iterations per frame\n         * };\n         * ```\n         *\n         * Override this when creating renderers.\n         **/\n        drawMeta: function( meta ){\n\n            // example:\n            // this.els.fps.innerHTML = meta.fps.toFixed(2);\n            // this.els.steps.innerHTML = meta.steps;\n            throw 'You must override the renderer.drawMeta() method.';\n        },\n\n        /**\n         * Renderer#drawBody( body, view )\n         * - body (Object): The body to draw\n         * - view (Object): The view for the body\n         *\n         * Draw specified body using specified view.\n         *\n         * Override this when creating renderers.\n         **/\n        drawBody: function( body, view ){\n\n            // example (pseudocode):\n            // view.angle = body.state.angle\n            // view.position = body.state.position\n            throw 'You must override the renderer.drawBody() method.';\n        }\n\n\n    });\n\n}());\n\n\n// ---\n// inside: src/core/world.js\n\n/** related to: Physics\n * class Physics.world\n *\n * The world class and factory function.\n *\n * Use [[Physics]] to create worlds.\n **/\n(function(){\n\n    var execCallbacks = function execCallbacks( fns, scope, args ){\n\n        var fn\n            ,ret\n            ,cb = function(){\n                return execCallbacks( fns, scope, args );\n            }\n            ;\n\n        while ( fn = fns.shift() ){\n\n            ret = fn.apply(scope, args);\n\n            if (ret && ret.then){\n                return ret.then( cb );\n            }\n        }\n    };\n\n    var defaults = {\n\n        // default timestep\n        timestep: 6,\n        // maximum number of iterations per step\n        maxIPF: 4,\n        webworker: false, // NOT YET IMPLEMENTED\n\n        // default integrator\n        integrator: 'verlet',\n\n        // is sleeping disabled?\n        sleepDisabled: false,\n        // speed at which bodies wake up\n        sleepSpeedLimit: 0.05,\n        // variance in position below which bodies fall asleep\n        sleepVarianceLimit: 0.02,\n        // time (ms) before sleepy bodies fall asleep\n        sleepTimeLimit: 500\n    };\n\n    // begin world definitions\n\n    /** alias of: Physics\n     * new Physics.world([options, fn(world, Physics)])\n     * - options (Object): configuration options (see description)\n     * - fn (Function|Array): Callback function or array of callbacks called with this === world\n     * - world (Physics.world): The current world created\n     * - Physics (Physics): The Physics namespace\n     *\n     * World Constructor.\n     *\n     * Use [[Physics]] to create worlds.\n     *\n     * Configuration options and defaults:\n     *\n     * ```javascript\n     * {\n     *  // default timestep\n     *  timestep: 6,\n     *  // maximum number of iterations per step\n     *  maxIPF: 4,\n     *\n     *  // default integrator\n     *  integrator: 'verlet',\n     *\n     *  // is sleeping disabled?\n     *  sleepDisabled: false,\n     *  // speed at which bodies wake up\n     *  sleepSpeedLimit: 0.1,\n     *  // variance in position below which bodies fall asleep\n     *  sleepVarianceLimit: 2,\n     *  // time (ms) before sleepy bodies fall asleep\n     *  sleepTimeLimit: 500\n     * }\n     * ```\n     *\n     * If called with an array of functions, and any functions\n     * return a [promise-like object](http://promises-aplus.github.io/promises-spec/),\n     * each remaining callback will be called only when that promise is resolved.\n     *\n     * Example:\n     *\n     * ```javascript\n     * // hypothetical resources need to be loaded...\n     * Physics( cfg, [\n     *     function( world ){\n     *         var dfd = $.Deferred()\n     *             ,images = []\n     *             ,toLoad = myImages.length\n     *             ,callback = function(){\n     *                 toLoad--;\n     *                 // wait for all images to be loaded\n     *                 if ( toLoad <= 0 ){\n     *                     dfd.resolve();\n     *                 }\n     *             }\n     *             ;\n     *\n     *         // load images\n     *         $.each(myImages, function( src ){\n     *             var img = new Image();\n     *             img.onload = callback;\n     *             img.src = src;\n     *         });\n     *\n     *         return dfd.promise();\n     *     },\n     *     function( world ){\n     *         // won't be executed until images are loaded\n     *         // initialize world... etc...\n     *     }\n     * ]);\n     * ```\n     **/\n    var World = function World( cfg, fn ){\n\n        // allow creation of world without \"new\"\n        if (!(this instanceof World)){\n            return new World( cfg, fn );\n        }\n\n        this.init( cfg, fn );\n    };\n\n    // extend pubsub\n    World.prototype = Physics.util.extend({}, Physics.util.pubsub.prototype, {\n\n        /** internal, see: new Physics.world\n         * Physics.world#init( [options, fn(world, Physics)] )\n         * - options (Object): configuration options (see constructor)\n         * - fn (Function|Array): Callback function or array of callbacks called with this === world\n         *\n         * Initialization\n         **/\n        init: function( cfg, fn ){\n\n            var self = this;\n\n            if ( Physics.util.isFunction( cfg ) || Physics.util.isArray( cfg ) ){\n                fn = cfg;\n                cfg = {};\n            }\n\n            this._meta = {\n               // statistics (fps, etc)\n               fps: 0,\n               ipf: 0\n            };\n            this._bodies = [];\n            this._behaviors = [];\n            this._integrator = null;\n            this._renderer = null;\n            this._paused = false;\n            this._warp = 1;\n            this._time = 0;\n\n            // set options\n            this.options = Physics.util.options( defaults );\n            this.options.onChange(function( opts ){\n\n                // set timestep\n                self.timestep( opts.timestep );\n            });\n            this.options( cfg );\n\n            // add integrator\n            this.add(Physics.integrator( this.options.integrator ));\n\n            // apply the callback function\n            if ( Physics.util.isFunction( fn ) ){\n\n                execCallbacks([ fn ], this, [this, Physics] );\n\n            } else if ( Physics.util.isArray( fn ) ){\n\n                execCallbacks(fn, this, [this, Physics] );\n            }\n        },\n\n        /**\n         * Physics.world#options( cfg ) -> Object\n         * - options (Object): configuration options (see constructor)\n         * + (Object): Options container\n         *\n         * Set config options. Also access options by `.options.<option>`.\n         **/\n        options: null,\n\n        /** chainable\n         * Physics.world#add( things ) -> this\n         * - things (Object|Array): The thing, or array of things (body, behavior, integrator, or renderer) to add.\n         *\n         * Multipurpose add method. Add one or many bodies, behaviors, integrators, renderers...\n         **/\n        add: function( arg ){\n\n            var i = 0\n                ,len = arg && arg.length || 0\n                ,thing = Physics.util.isArray( arg ) ? arg[ 0 ] : arg\n                ;\n\n            if ( !thing ){\n                return this;\n            }\n\n            // we'll either cycle through an array\n            // or just run this on the arg itself\n            do {\n                switch (thing.type){\n\n                    case 'behavior':\n                        this.addBehavior(thing);\n                    break; // end behavior\n\n                    case 'integrator':\n                        this.integrator(thing);\n                    break; // end integrator\n\n                    case 'renderer':\n                        this.renderer(thing);\n                    break; // end renderer\n\n                    case 'body':\n                        this.addBody(thing);\n                    break; // end body\n\n                    default:\n                        throw 'Error: failed to add item of unknown type \"'+ thing.type +'\" to world';\n                    // end default\n                }\n\n            } while ( ++i < len && (thing = arg[ i ]) );\n\n            return this;\n        },\n\n        /** chainable\n         * Physics.world#remove( things ) -> this\n         * - things (Object|Array): The thing, or array of things (body, behavior, integrator, or renderer) to remove.\n         *\n         * Multipurpose remove method. Remove one or many bodies, behaviors, integrators, renderers...\n         **/\n        remove: function( arg ){\n\n            var i = 0\n                ,len = arg && arg.length || 0\n                ,thing = Physics.util.isArray( arg ) ? arg[ 0 ] : arg\n                ;\n\n            if ( !thing ){\n                return this;\n            }\n\n            // we'll either cycle through an array\n            // or just run this on the arg itself\n            do {\n                switch (thing.type){\n\n                    case 'behavior':\n                        this.removeBehavior( thing );\n                    break; // end behavior\n\n                    case 'integrator':\n                        if (thing === this._integrator){\n                            this.integrator( null );\n                        }\n                    break; // end integrator\n\n                    case 'renderer':\n                        if (thing === this._renderer){\n                            this.renderer( null );\n                        }\n                    break; // end renderer\n\n                    case 'body':\n                        this.removeBody( thing );\n                    break; // end body\n\n                    default:\n                        throw 'Error: failed to remove item of unknown type \"'+ thing.type +'\" from world';\n                    // end default\n                }\n\n            } while ( ++i < len && (thing = arg[ i ]) );\n\n            return this;\n        },\n\n        /** chainable\n         * Physics.world#has( thing ) -> Boolean\n         * - thing (Object): The thing to test\n         * + (Boolean): `true` if thing is in the world, `false` otherwise.\n         *\n         * Determine if a thing has been added to world.\n         **/\n        has: function( thing ){\n\n            var arr\n                ,i\n                ,l\n                ;\n\n            if ( !thing ){\n                return false;\n            }\n\n            switch (thing.type){\n\n                case 'behavior':\n                    arr = this._behaviors;\n                break; // end behavior\n\n                case 'integrator':\n                return ( this._integrator === thing );\n                // end integrator\n\n                case 'renderer':\n                return ( this._renderer === thing );\n                // end renderer\n\n                case 'body':\n                    arr = this._bodies;\n                break; // end body\n\n                default:\n                    throw 'Error: unknown type \"'+ thing.type +'\"';\n                // end default\n            }\n\n            // check array\n            return (Physics.util.indexOf( arr, thing ) > -1);\n        },\n\n        /** chainable\n         * Physics.world#integrator( [integrator] ) -> Integrator|this\n         * - integrator (Integrator): The integrator to set on the world\n         * + (Integrator): The currently set integrator if `integrator` not specified\n         * + (this): for chaining if `integrator` specified\n         *\n         * Get or Set the integrator\n         **/\n        integrator: function( integrator ){\n\n            if ( integrator === undefined ){\n                return this._integrator;\n            }\n\n            // do nothing if already added\n            if ( this._integrator === integrator ){\n                return this;\n            }\n\n            if ( this._integrator ){\n\n                this._integrator.setWorld( null );\n\n                this.emit( 'remove:integrator', {\n                    integrator: this._integrator\n                });\n            }\n\n            if ( integrator ){\n                this._integrator = integrator;\n                this._integrator.setWorld( this );\n\n                this.emit( 'add:integrator', {\n                    integrator: this._integrator\n                });\n            }\n\n            return this;\n        },\n\n        /** chainable\n         * Physics.world#renderer( [renderer] ) -> Renderer|this\n         * - renderer (Renderer): The renderer to set on the world\n         * + (Renderer): The currently set renderer if `renderer` not specified\n         * + (this): for chaining if `renderer` specified\n         *\n         * Get or Set the renderer\n         **/\n        renderer: function( renderer ){\n\n            if ( renderer === undefined ){\n                return this._renderer;\n            }\n\n            // do nothing if renderer already added\n            if ( this._renderer === renderer ){\n                return this;\n            }\n\n            if ( this._renderer ){\n\n                this._renderer.setWorld( null );\n\n                this.emit( 'remove:renderer', {\n                    renderer: this._renderer\n                });\n            }\n\n            if ( renderer ){\n                this._renderer = renderer;\n                this._renderer.setWorld( this );\n\n                this.emit( 'add:renderer', {\n                    renderer: this._renderer\n                });\n            }\n\n            return this;\n        },\n\n        /** chainable\n         * Physics.world#timestep( [dt] ) -> Number|this\n         * - dt (Number): The time step for the world\n         * + (Number): The currently set time step if `dt` not specified\n         * + (this): for chaining if `dt` specified\n         *\n         * Get or Set the timestep\n         **/\n        timestep: function( dt ){\n\n            if ( dt ){\n\n                this._dt = +dt.toPrecision(4); // only keep 4 decimal places of precision otherwise we get rounding errors\n                // calculate the maximum jump in time over which to do iterations\n                this._maxJump = dt * this.options.maxIPF;\n\n                return this;\n            }\n\n            return this._dt;\n        },\n\n        /** chainable\n         * Physics.world#wakeUpAll() -> this\n         * + (this): for chaining\n         *\n         * Wake up all bodies in world.\n         **/\n        wakeUpAll: function(){\n            var i = 0\n                ,l = this._bodies.length\n                ;\n\n            for ( i = 0; i < l; i++ ){\n                this._bodies[ i ].sleep( false );\n            }\n        },\n\n        /** chainable\n         * Physics.world#addBehavior( behavior ) -> this\n         * - behavior (Behavior): The behavior to add\n         *\n         * Add a behavior to the world\n         **/\n        addBehavior: function( behavior ){\n\n            var notify;\n\n            // don't allow duplicates\n            if ( this.has( behavior ) ){\n                return this;\n            }\n\n            behavior.setWorld( this );\n            this._behaviors.push( behavior );\n\n            this.emit( 'add:behavior', {\n                behavior: behavior\n            });\n\n            return this;\n        },\n\n        /**\n         * Physics.world#getBehaviors() -> Array\n         * + (Array): Array of behaviors\n         *\n         * Get copied list of behaviors in the world\n         **/\n        getBehaviors: function(){\n\n            // return the copied array\n            return [].concat(this._behaviors);\n        },\n\n        /** chainable\n         * Physics.world#removeBehavior( behavior ) -> this\n         * - behavior (Behavior): The behavior to remove\n         *\n         * Remove a behavior from the world\n         **/\n        removeBehavior: function( behavior ){\n\n            var behaviors = this._behaviors;\n\n            if (behavior){\n\n                for ( var i = 0, l = behaviors.length; i < l; ++i ){\n\n                    if (behavior === behaviors[ i ]){\n\n                        behaviors.splice( i, 1 );\n                        behavior.setWorld( null );\n\n                        this.emit( 'remove:behavior', {\n                            behavior: behavior\n                        });\n\n                        break;\n                    }\n                }\n            }\n\n            return this;\n        },\n\n        /** chainable\n         * Physics.world#addBody( body ) -> this\n         * - body (Body): The behavior to add\n         *\n         * Add a body to the world\n         **/\n        addBody: function( body ){\n\n            var notify;\n\n            // don't allow duplicates\n            if ( this.has( body ) ){\n                return this;\n            }\n\n            body.setWorld( this );\n            this._bodies.push( body );\n\n            this.emit( 'add:body', {\n                body: body\n            });\n\n            return this;\n        },\n\n        /**\n         * Physics.world#getBodies() -> Array\n         * + (Array): Array of bodies\n         *\n         * Get copied list of bodies in the world\n         **/\n        getBodies: function(){\n\n            // return the copied array\n            return [].concat(this._bodies);\n        },\n\n        /** chainable\n         * Physics.world#removeBody( body ) -> this\n         * - body (Body): The body to remove\n         *\n         * Remove a body from the world\n         **/\n        removeBody: function( body ){\n\n            var bodies = this._bodies;\n\n            if (body){\n\n                for ( var i = 0, l = bodies.length; i < l; ++i ){\n\n                    if (body === bodies[ i ]){\n\n                        bodies.splice( i, 1 );\n                        body.setWorld( null );\n\n                        this.emit( 'remove:body', {\n                            body: body\n                        });\n\n                        break;\n                    }\n                }\n            }\n\n            return this;\n        },\n\n        /** see: Physics.query\n         * Physics.world#findOne( rules ) -> Body | false\n         * Physics.world#findOne( filter(body) ) -> Body | false\n         * - rules (Object): Query rules.\n         * - filter (Function): Filter function called to check bodies\n         * - body (Body): Each body in the world\n         *\n         * Find first matching body based on query rules.\n         **/\n        findOne: function( rules ){\n\n            var self = this\n                ,fn = (typeof rules === 'function') ? rules : Physics.query( rules )\n                ;\n\n            return Physics.util.find( self._bodies, fn ) || false;\n        },\n\n        /** see: Physics.query\n         * Physics.world#find( rules ) -> Array\n         * Physics.world#find( filter(body) ) -> Array\n         * - rules (Object): Query rules\n         * - filter (Function): Filter function called to check bodies\n         * - body (Body): Each body in the world\n         *\n         * Find all matching bodies based on query rules.\n         **/\n        find: function( rules ){\n\n            var self = this\n                ,fn = (typeof rules === 'function') ? rules : Physics.query( rules )\n                ;\n\n            return Physics.util.filter( self._bodies, fn );\n        },\n\n        /** internal\n         * Physics.world#iterate( dt )\n         * - dt (Number): The timestep\n         *\n         * Do a single iteration.\n         **/\n        iterate: function( dt ){\n\n            this._integrator.integrate( this._bodies, dt );\n        },\n\n        /** chainable\n         * Physics.world#step( [now] ) -> this\n         * - now (Number): Current unix timestamp\n         *\n         * Step the world up to specified time or do one step if no time is specified.\n         **/\n        step: function( now ){\n\n            var time = this._time\n                ,warp = this._warp\n                ,invWarp = 1 / warp\n                ,dt = this._dt\n                ,animDt = dt * invWarp\n                ,animMaxJump = this._maxJump * invWarp\n                ,animDiff\n                ,worldDiff\n                ,target\n                ,meta = this._meta\n                ;\n\n            // if it's paused, don't step\n            // or if it's the first step...\n            if ( this._paused || this._animTime === undefined ){\n                this._animTime = now || this._animTime || Physics.util.ticker.now();\n\n                if ( !this._paused ){\n                    this.emit('step', meta);\n                }\n                return this;\n            }\n\n            // new time is specified, or just one iteration ahead\n            now = now || (this._animTime + animDt);\n            // the time between this step and the last\n            animDiff = now - this._animTime;\n\n            // if the time difference is too big... adjust\n            if ( animDiff > animMaxJump ){\n                this._animTime = now - animMaxJump;\n                animDiff = animMaxJump;\n            }\n\n            // the \"world\" time between this step and the last. Adjusts for warp\n            worldDiff = animDiff * warp;\n\n            // the target time for the world time to step to\n            target = time + worldDiff - dt;\n\n            this.emit('beforeStep');\n\n            if ( time <= target ){\n\n                while ( time <= target ){\n                    // increment world time\n                    time += dt;\n                    // increment animation time\n                    this._animTime += animDt;\n                    // record the world time\n                    this._time = time;\n                    // iterate by one timestep\n                    this.iterate( dt );\n                }\n            }\n\n            // set some meta\n            meta.fps = 1000 / (now - this._lastTime); // frames per second\n            meta.ipf = (worldDiff / dt).toFixed(2); // iterations per frame\n            meta.interpolateTime = dt + target - time;\n\n            // record the time this was called\n            this._lastTime = now;\n\n            this.emit('step', meta);\n            return this;\n        },\n\n        /**\n         * Physics.world#warp( [warp] ) -> this|Number\n         * - warp (Number): The time warp factor\n         *\n         * Speed up or slow down the iteration by this factor.\n         *\n         * Example:\n         * ```javascript\n         * // slow motion... 10x slower\n         * world.warp( 0.01 );\n         * ```\n         **/\n        warp: function( warp ){\n            if ( warp === undefined ){\n                return this._warp;\n            }\n\n            this._warp = warp || 1;\n\n            return this;\n        },\n\n        /** chainable\n         * Physics.world#render() -> this\n         *\n         * Render current world state using the renderer\n         **/\n        render: function(){\n\n            if ( !this._renderer ){\n                throw \"No renderer added to world\";\n            }\n\n            this._renderer.render( this._bodies, this._meta );\n            this.emit('render', {\n                bodies: this._bodies,\n                meta: this._meta,\n                renderer: this._renderer\n            });\n            return this;\n        },\n\n        /** chainable\n         * Physics.world#pause() -> this\n         *\n         * Pause the world (step calls do nothing).\n         **/\n        pause: function(){\n\n            this._paused = true;\n            this.emit('pause');\n            return this;\n        },\n\n        /** chainable\n         * Physics.world#unpause() -> this\n         *\n         * Unpause the world (step calls continue as usual).\n         **/\n        unpause: function(){\n\n            this._paused = false;\n            this.emit('unpause');\n            return this;\n        },\n\n        /**\n         * Physics.world#isPaused() -> Boolean\n         * + (Boolean): Returns `true` if world is paused, `false` otherwise.\n         *\n         * Determine if world is paused.\n         **/\n        isPaused: function(){\n\n            return !!this._paused;\n        },\n\n        /**\n         * Physics.world#destroy()\n         *\n         * Destroy the world.\n         * (Bwahahahahaha!)\n         **/\n        destroy: function(){\n\n            var self = this;\n            self.pause();\n\n            // notify before\n            this.emit('destroy');\n\n            // remove all listeners\n            self.off( true );\n            // remove everything\n            self.remove( self.getBodies() );\n            self.remove( self.getBehaviors() );\n            self.integrator( null );\n            self.renderer( null );\n        }\n\n    });\n\n    Physics.world = World;\n\n}());\n\n\n// ---\n// inside: src/integrators/verlet.js\n\nPhysics.integrator('verlet', function( parent ){\n\n    // for this integrator we need to know if the object has been integrated before\n    // so let's add a mixin to bodies\n\n    Physics.body.mixin({\n\n        started: function( val ){\n            if ( val !== undefined ){\n                this._started = true;\n            }\n\n            return !!this._started;\n        }\n    });\n\n\n    return {\n        /**\n         * class Verlet < Integrator\n         *\n         * `Physics.integrator('verlet')`.\n         *\n         * The verlet integrator.\n         **/\n\n        // extended\n        init: function( options ){\n\n            // call parent init\n            parent.init.call(this, options);\n        },\n\n        // extended\n        integrateVelocities: function( bodies, dt ){\n\n            // half the timestep\n            var dtdt = dt * dt\n                ,drag = 1 - this.options.drag\n                ,body = null\n                ,state\n                ,prevDt = this.prevDt || dt\n                ,dtMul = (dtdt + dt * prevDt) * 0.5\n                ;\n\n            for ( var i = 0, l = bodies.length; i < l; ++i ){\n\n                body = bodies[ i ];\n                state = body.state;\n\n                // only integrate if the body isn't static\n                if ( body.treatment !== 'static' && !body.sleep( dt ) ){\n\n                    // Inspired from https://github.com/soulwire/Coffee-Physics\n                    // @licence MIT\n                    //\n                    // v = x - ox\n                    // x = x + (v + a * dt * dt)\n\n                    // use the velocity in vel if the velocity has been changed manually\n                    if (state.vel.equals( state.old.vel ) && body.started()){\n\n                        // Get velocity by subtracting old position from curr position\n                        state.vel.clone( state.pos ).vsub( state.old.pos );\n\n                    } else {\n\n                        state.old.pos.clone( state.pos ).vsub( state.vel );\n                        // so we need to scale the value by dt so it\n                        // complies with other integration methods\n                        state.vel.mult( dt );\n                    }\n\n                    // Apply \"air resistance\".\n                    if ( drag ){\n\n                        state.vel.mult( drag );\n                    }\n\n                    // Apply acceleration\n                    // v += a * dt * dt\n                    state.vel.vadd( state.acc.mult( dtMul ) );\n\n                    // restore velocity\n                    state.vel.mult( 1/dt );\n\n                    // store calculated velocity\n                    state.old.vel.clone( state.vel );\n\n                    // Reset accel\n                    state.acc.zero();\n\n                    //\n                    // Angular components\n                    //\n\n                    if (state.angular.vel === state.old.angular.vel && body.started()){\n\n                        state.angular.vel = (state.angular.pos - state.old.angular.pos);\n\n                    } else {\n\n                        state.old.angular.pos = state.angular.pos - state.angular.vel;\n                        state.angular.vel *= dt;\n                    }\n\n                    state.angular.vel += state.angular.acc * dtMul;\n                    state.angular.vel /= dt;\n                    state.old.angular.vel = state.angular.vel;\n                    state.angular.acc = 0;\n\n                    body.started( true );\n\n                } else {\n                    // set the velocity and acceleration to zero!\n                    state.vel.zero();\n                    state.acc.zero();\n                    state.angular.vel = 0;\n                    state.angular.acc = 0;\n                }\n            }\n        },\n\n        // extended\n        integratePositions: function( bodies, dt ){\n\n            // half the timestep\n            var dtdt = dt * dt\n                ,body = null\n                ,state\n                ,prevDt = this.prevDt || dt\n                ,dtcorr = dt/prevDt\n                ;\n\n            for ( var i = 0, l = bodies.length; i < l; ++i ){\n\n                body = bodies[ i ];\n                state = body.state;\n\n                // only integrate if the body isn't static\n                if ( body.treatment !== 'static' && !body.sleep() ){\n\n                    // so we need to scale the value by dt so it\n                    // complies with other integration methods\n                    state.vel.mult( dt * dtcorr );\n\n                    // Store old position.\n                    // xold = x\n                    state.old.pos.clone( state.pos );\n\n                    state.pos.vadd( state.vel );\n\n                    // restore velocity\n                    state.vel.mult( 1 / (dt * dtcorr) );\n\n                    // store calculated velocity\n                    state.old.vel.clone( state.vel );\n\n                    //\n                    // Angular components\n                    //\n\n\n                    state.angular.vel *= dt * dtcorr;\n\n                    state.old.angular.pos = state.angular.pos;\n\n                    state.angular.pos += state.angular.vel;\n                    state.angular.vel /= dt * dtcorr;\n                    state.old.angular.vel = state.angular.vel;\n                }\n            }\n\n            this.prevDt = dt;\n        }\n    };\n});\n\n\n// ---\n// inside: src/geometries/point.js\n\n/** alias of: Geometry\n * class PointGeometry < Geometry\n *\n * Physics.geometry('point')\n *\n * The point geometry represents a point.\n **/\nPhysics.geometry('point', function( parent ){});\n\n\n// ---\n// inside: src/bodies/point.js\n\n/** alias of: Body\n * class PointBody < Body\n *\n * Physics.body('point')\n *\n * The point body represents a point.\n **/\nPhysics.body('point', function( parent ){\n    return {\n        init: function( opts ){\n            parent.init.call( this, opts );\n            this.moi = 0;\n        }\n    };\n});\n\n\n// ---\n// inside: src/geometries/circle.js\n\n/** \n * class CircleGeometry < Geometry\n *\n * Physics.geometry('circle')\n *\n * The circle geometry has a circular shape.\n *\n * Additional options include:\n * - radius: the radius\n *\n * Example:\n *\n * ```javascript\n * var round = Physics.body('circle', {\n *     x: 30,\n *     y: 20,\n *     radius: 5\n * });\n * ```\n **/\nPhysics.geometry('circle', function( parent ){\n\n    var defaults = {\n\n        radius: 1.0\n    };\n\n    return {\n\n        // extended\n        init: function( options ){\n\n            var self = this;\n            // call parent init method\n            parent.init.call(this, options);\n\n            this.options.defaults( defaults );\n            this.options.onChange(function( opts ){\n                this.radius = opts.radius;\n            });\n            this.options( options );\n\n            this._aabb = Physics.aabb();\n            this.radius = this.options.radius;\n        },\n                \n        // extended\n        aabb: function( angle ){\n\n            var r = this.radius\n                ;\n\n            // circles are symetric... so angle has no effect\n            if ( this._aabb.hw !== r ){\n                // recalculate\n                this._aabb = Physics.aabb( -r, -r, r, r );\n            }\n\n            return Physics.aabb.clone( this._aabb );\n        },\n\n        // extended\n        getFarthestHullPoint: function( dir, result ){\n\n            result = result || new Physics.vector();\n\n            return result.clone( dir ).normalize().mult( this.radius );\n        },\n\n        // extended\n        getFarthestCorePoint: function( dir, result, margin ){\n\n            result = result || new Physics.vector();\n\n            // we can use the center of the circle as the core object\n            // because we can project a point to the hull in any direction\n            // ... yay circles!\n            // but since the caller is expecting a certain margin... give it\n            // to them\n            return result.clone( dir ).normalize().mult( this.radius - margin );\n        }\n    };\n});\n\n\n// ---\n// inside: src/geometries/compound.js\n\n/**\n * class CompoundGeometry < Geometry\n *\n * Physics.geometry('compound')\n *\n * Geometry for compound shapes.\n *\n * Example:\n *\n * ```javascript\n * var thing = Physics.geometry('compound');\n * thing.addChild( child, pos, rotation );\n * ```\n **/\nPhysics.geometry('compound', function( parent ){\n\n    var defaults = {\n\n    };\n\n    return {\n\n        // extended\n        init: function( options ){\n\n            var self = this;\n\n            // call parent init method\n            parent.init.call(this, options);\n\n            this.options.defaults( defaults );\n            this.options( options );\n\n            this.children = [];\n        },\n\n        /**\n         * CompoundGeometry#addChild( geometry, pos ) -> this\n         * - geometry (Geometry): The child to add.\n         * - pos (Physics.vector): The position to add the child at.\n         * - angle (Number): The rotation angle\n         *\n         * Add a child at relative position.\n         **/\n        addChild: function( geometry, pos, angle ){\n\n            this._aabb = null;\n            this.children.push({\n                g: geometry\n                ,pos: new Physics.vector( pos )\n                ,angle: angle\n            });\n\n            return this;\n        },\n\n        /**\n         * CompoundGeometry#clear() -> this\n         *\n         * Remove all children.\n         **/\n        clear: function(){\n\n            this._aabb = null;\n            this.children = [];\n\n            return this;\n        },\n\n        // extended\n        aabb: function( angle ){\n\n            if (!angle && this._aabb){\n                return Physics.aabb.clone( this._aabb );\n            }\n\n            var b\n                ,aabb\n                ,ch\n                ,ret\n                ,scratch = Physics.scratchpad()\n                ,pos = Physics.vector()\n                ;\n\n            angle = angle || 0;\n\n            for ( var i = 0, l = this.children.length; i < l; i++ ) {\n                ch = this.children[ i ];\n                // the aabb rotated by overall angle and the child rotation\n                aabb = ch.g.aabb( angle + ch.angle );\n                pos.clone( ch.pos );\n                if ( angle ){\n                    // get the child's position rotated if needed\n                    pos.rotate( angle );\n                }\n                // move the aabb to the child's position\n                aabb.x += pos._[0];\n                aabb.y += pos._[1];\n                ret = ret ? Physics.aabb.union(ret, aabb, true) : aabb;\n            }\n\n            if ( !angle ){\n                // if we don't have an angle specified (or it's zero)\n                // then we can cache this result\n                this._aabb = Physics.aabb.clone( ret );\n            }\n\n            return scratch.done( ret );\n        },\n\n        // extended\n        // NOTE: unlike other geometries this can't be used in the\n        // GJK algorithm because the shape isn't garanteed to be convex\n        getFarthestHullPoint: function( dir, result ){\n\n            var ch\n                ,i\n                ,l = this.children.length\n                ,scratch = Physics.scratchpad()\n                ,v = scratch.vector()\n                ,len = 0\n                ,maxlen = 0\n                ;\n\n            result = result || new Physics.vector();\n\n            // find the one with the largest projection along dir\n            for ( i = 0; i < l; i++ ) {\n                ch = this.children[ i ];\n                ch.g.getFarthestHullPoint( dir.rotate(-ch.angle), v );\n                len = v.rotate(ch.angle).vadd( ch.pos ).proj( dir.rotate(ch.angle) );\n\n                if ( len > maxlen ){\n                    maxlen = len;\n                    result.swap( v );\n                }\n            }\n\n            return scratch.done( result );\n        },\n\n        // extended\n        // NOTE: unlike other geometries this can't be used in the\n        // GJK algorithm because the shape isn't garanteed to be convex\n        getFarthestCorePoint: function( dir, result, margin ){\n\n            var ch\n                ,i\n                ,l = this.children.length\n                ,scratch = Physics.scratchpad()\n                ,v = scratch.vector()\n                ,len = 0\n                ,maxlen = 0\n                ;\n\n            result = result || new Physics.vector();\n\n            // find the one with the largest projection along dir\n            for ( i = 0; i < l; i++ ) {\n                ch = this.children[ i ];\n                ch.g.getFarthestCorePoint(dir.rotate(-ch.angle), v, margin );\n                len = v.rotate(ch.angle).vadd( ch.pos ).proj( dir.rotate(ch.angle) );\n\n                if ( len > maxlen ){\n                    maxlen = len;\n                    result.swap( v );\n                }\n            }\n\n            return scratch.done( result );\n        }\n    };\n});\n\n\n// ---\n// inside: src/geometries/convex-polygon.js\n\n/**\n * class ConvexPolygonGeometry < Geometry\n *\n * Physics.geometry('convex-polygon')\n *\n * Geometry for convex polygons.\n *\n * Additional config options:\n *\n * - vertices: Array of [[Vectorish]] objects representing the polygon vertices in clockwise (or counterclockwise) order.\n *\n * Example:\n *\n * ```javascript\n * var pentagon = Physics.geometry('convex-polygon', {\n *     // the centroid is automatically calculated and used to position the shape\n *     vertices: [\n *         { x: 0, y: -30 },\n *         { x: -29, y: -9 },\n *         { x: -18, y: 24 },\n *         { x: 18, y: 24 },\n *         { x: 29, y: -9 }\n *     ]\n * });\n * ```\n **/\nPhysics.geometry('convex-polygon', function( parent ){\n\n    var ERROR_NOT_CONVEX = 'Error: The vertices specified do not match that of a _convex_ polygon.';\n\n    var defaults = {\n\n    };\n\n    return {\n\n        // extended\n        init: function( options ){\n\n            var self = this;\n\n            // call parent init method\n            parent.init.call(this, options);\n\n            this.options.defaults( defaults );\n            this.options.onChange(function( opts ){\n                self.setVertices( opts.vertices || [] );\n            });\n            this.options( options );\n\n            self.setVertices( this.options.vertices || [] );\n\n        },\n\n        /**\n         * ConvexPolygonGeometry#setVertices( hull ) -> this\n         * - hull (Array): Vertices represented by an array of [[Vectorish]] objects, in either clockwise or counterclockwise order\n         *\n         * Set the vertices of this polygon.\n         **/\n        setVertices: function( hull ){\n\n            var scratch = Physics.scratchpad()\n                ,transl = scratch.transform()\n                ,verts = this.vertices = []\n                ;\n\n            if ( !Physics.geometry.isPolygonConvex( hull ) ){\n                throw ERROR_NOT_CONVEX;\n            }\n\n            transl.setRotation( 0 );\n            transl.setTranslation( Physics.geometry.getPolygonCentroid( hull ).negate() );\n\n            // translate each vertex so that the centroid is at the origin\n            // then add the vertex as a vector to this.vertices\n            for ( var i = 0, l = hull.length; i < l; ++i ){\n\n                verts.push( new Physics.vector( hull[ i ] ).translate( transl ) );\n            }\n\n            this._area = Physics.geometry.getPolygonArea( verts );\n            this._aabb = false;\n            return scratch.done(this);\n        },\n\n        // extended\n        aabb: function( angle ){\n\n            if (!angle && this._aabb){\n                return Physics.aabb.clone( this._aabb );\n            }\n\n            var scratch = Physics.scratchpad()\n                ,p = scratch.vector()\n                ,trans = scratch.transform().setRotation( angle || 0 )\n                ,xaxis = scratch.vector().set( 1, 0 ).rotateInv( trans )\n                ,yaxis = scratch.vector().set( 0, 1 ).rotateInv( trans )\n                ,xmax = this.getFarthestHullPoint( xaxis, p ).proj( xaxis )\n                ,xmin = - this.getFarthestHullPoint( xaxis.negate(), p ).proj( xaxis )\n                ,ymax = this.getFarthestHullPoint( yaxis, p ).proj( yaxis )\n                ,ymin = - this.getFarthestHullPoint( yaxis.negate(), p ).proj( yaxis )\n                ,aabb\n                ;\n\n            aabb = Physics.aabb( xmin, ymin, xmax, ymax );\n\n            if (!angle){\n                // if we don't have an angle specified (or it's zero)\n                // then we can cache this result\n                this._aabb = Physics.aabb.clone( aabb );\n            }\n\n            scratch.done();\n            return aabb;\n        },\n\n        // extended\n        getFarthestHullPoint: function( dir, result, data ){\n\n            var verts = this.vertices\n                ,val\n                ,prev\n                ,l = verts.length\n                ,i = 2\n                ,idx\n                ;\n\n            result = result || new Physics.vector();\n\n            if ( l < 2 ){\n                if ( data ){\n                    data.idx = 0;\n                }\n                return result.clone( verts[0] );\n            }\n\n            prev = verts[ 0 ].dot( dir );\n            val = verts[ 1 ].dot( dir );\n\n            if ( l === 2 ){\n                idx = (val >= prev) ? 1 : 0;\n                if ( data ){\n                    data.idx = idx;\n                }\n                return result.clone( verts[ idx ] );\n            }\n\n            if ( val >= prev ){\n                // go up\n                // search until the next dot product\n                // is less than the previous\n                while ( i < l && val >= prev ){\n                    prev = val;\n                    val = verts[ i ].dot( dir );\n                    i++;\n                }\n\n                if (val >= prev){\n                    i++;\n                }\n\n                // return the previous (furthest with largest dot product)\n                idx = i - 2;\n                if ( data ){\n                    data.idx = i - 2;\n                }\n                return result.clone( verts[ idx ] );\n\n            } else {\n                // go down\n\n                i = l;\n                while ( i > 1 && prev >= val ){\n                    i--;\n                    val = prev;\n                    prev = verts[ i ].dot( dir );\n                }\n\n                // return the previous (furthest with largest dot product)\n                idx = (i + 1) % l;\n                if ( data ){\n                    data.idx = idx;\n                }\n                return result.clone( verts[ idx ] );\n            }\n        },\n\n        // extended\n        getFarthestCorePoint: function( dir, result, margin ){\n\n            var norm\n                ,scratch = Physics.scratchpad()\n                ,next = scratch.vector()\n                ,prev = scratch.vector()\n                ,verts = this.vertices\n                ,l = verts.length\n                ,mag\n                ,sign = this._area > 0\n                ,data = {}\n                ;\n\n            result = this.getFarthestHullPoint( dir, result, data );\n\n            // get normalized directions to next and previous vertices\n            next.clone( verts[ (data.idx + 1) % l ] ).vsub( result ).normalize().perp( sign );\n            prev.clone( verts[ (data.idx - 1 + l) % l ] ).vsub( result ).normalize().perp( !sign );\n\n            // get the magnitude of a vector from the result vertex\n            // that splits down the middle\n            // creating a margin of \"m\" to each edge\n            mag = margin / (1 + next.dot(prev));\n\n            result.vadd( next.vadd( prev ).mult( mag ) );\n            scratch.done();\n            return result;\n        }\n    };\n});\n\n\n// ---\n// inside: src/geometries/rectangle.js\n\n/**\n * class RectangleGeometry < Geometry\n *\n * Physics.geometry('rectangle')\n *\n * Geometry for rectangles.\n *\n * Additional config options:\n *\n * - width: The width\n * - height: The height\n *\n * Example:\n *\n * ```javascript\n * var rectGeo = Physics.geometry('rectangle', {\n *     width: 30,\n *     height: 40\n * });\n * ```\n **/\nPhysics.geometry('rectangle', function( parent ){\n\n    var defaults = {\n\n    };\n\n    return {\n\n        // extended\n        init: function( options ){\n\n            var self = this;\n\n            // call parent init method\n            parent.init.call(this, options);\n\n            this.options.defaults( defaults );\n            this.options.onChange(function( opts ){\n                /**\n                 * RectangleGeometry#width = Number\n                 *\n                 * The width\n                 **/\n                self.width = self.options.width || 1;\n                /**\n                 * RectangleGeometry#height = Number\n                 *\n                 * The height\n                 **/\n                self.height = self.options.height || 1;\n            });\n            this.options( options );\n        },\n\n        // extended\n        aabb: function( angle ){\n\n            if (!angle){\n                return Physics.aabb( this.width, this.height );\n            }\n\n            var scratch = Physics.scratchpad()\n                ,p = scratch.vector()\n                ,trans = scratch.transform().setRotation( angle || 0 )\n                ,xaxis = scratch.vector().set( 1, 0 ).rotateInv( trans )\n                ,yaxis = scratch.vector().set( 0, 1 ).rotateInv( trans )\n                ,xmax = this.getFarthestHullPoint( xaxis, p ).proj( xaxis )\n                ,xmin = - this.getFarthestHullPoint( xaxis.negate(), p ).proj( xaxis )\n                ,ymax = this.getFarthestHullPoint( yaxis, p ).proj( yaxis )\n                ,ymin = - this.getFarthestHullPoint( yaxis.negate(), p ).proj( yaxis )\n                ;\n\n            scratch.done();\n            return Physics.aabb( xmin, ymin, xmax, ymax );\n        },\n\n        // extended\n        getFarthestHullPoint: function( dir, result ){\n\n            result = result || new Physics.vector();\n\n            var x = dir.x\n                ,y = dir.y\n                ;\n\n            x = x === 0 ? 0 : x < 0 ? -this.width * 0.5 : this.width * 0.5;\n            y = y === 0 ? 0 : y < 0 ? -this.height * 0.5 : this.height * 0.5;\n\n            return result.set( x, y );\n        },\n\n        // extended\n        getFarthestCorePoint: function( dir, result, margin ){\n\n            var x, y;\n            result = this.getFarthestHullPoint( dir, result );\n            x = result.x;\n            y = result.y;\n            result.x = x === 0 ? 0 : x < 0 ? x + margin : x - margin;\n            result.y = y === 0 ? 0 : y < 0 ? y + margin : y - margin;\n\n            return result;\n        }\n    };\n});\n\n\n// ---\n// inside: src/bodies/circle.js\n\n/*\n * @requires geometries/circle\n */\n/** \n * class CircleBody < Body\n *\n * Physics.body('circle')\n *\n * The circle body has a circular shape.\n *\n * Additional options include:\n * - radius: the radius\n *\n * Example:\n *\n * ```javascript\n * var round = Physics.body('circle', {\n *     x: 30,\n *     y: 20,\n *     radius: 5\n * });\n * ```\n **/\nPhysics.body('circle', function( parent ){\n\n    var defaults = {\n        radius: 1.0\n    };\n\n    return {\n\n        // extended\n        init: function( options ){\n\n            // call parent init method\n            parent.init.call(this, options);\n\n            options = Physics.util.extend({}, defaults, options);\n\n            this.geometry = Physics.geometry('circle', {\n                radius: options.radius\n            });\n\n            this.recalc();\n        },\n\n        // extended\n        recalc: function(){\n            parent.recalc.call(this);\n            // moment of inertia\n            this.moi = this.mass * this.geometry.radius * this.geometry.radius / 2;\n        }\n    };\n});\n\n\n// ---\n// inside: src/bodies/compound.js\n\n/*\n * @requires geometries/compound\n */\n /**\n  * class CompoundBody < Body\n  *\n  * Physics.body('compound')\n  *\n  * Not a body in itself. It's a container to group other bodies. The position of the body is the center of mass.\n  * It must have at least one child before being added to the world.\n  *\n  * Additional config options:\n  *\n  * - children: Array of [[Body]] objects.\n  *\n  * Example:\n  *\n  * ```javascript\n  * var thing = Physics.body('compound', {\n  *     // place the center of mass at (300, 200)\n  *     x: 300,\n  *     y: 200,\n  *     // the center of mass is automatically calculated and used to position the shape\n  *     children: [\n  *         body1,\n  *         body2,\n  *         // ...\n  *     ]\n  * });\n  * ```\n  **/\nPhysics.body('compound', function( parent ){\n\n    var defaults = {\n\n    };\n\n    return {\n\n        // extended\n        init: function( options ){\n\n            // call parent init method\n            parent.init.call(this, options);\n\n            this.mass = 0;\n            this.moi = 0;\n\n            this.children = [];\n            this.geometry = Physics.geometry('compound');\n            this.addChildren( options.children );\n        },\n\n        // extended\n        connect: function( world ){\n            // sanity check\n            if ( this.mass <= 0 ){\n                throw 'Can not add empty compound body to world.';\n            }\n        },\n\n        /**\n         * CompoundBody#addChild( body ) -> this\n         * - body (Body): The child to add\n         *\n         * Add a body as a child.\n         **/\n        addChild: function( body ){\n\n            this.addChildren([ body ]);\n            return this;\n        },\n\n        /**\n         * CompoundBody#addChildren( bodies ) -> this\n         * - bodies (Array): The list of children to add\n         *\n         * Add an array of children to the compound.\n         **/\n        addChildren: function( bodies ){\n\n            var self = this\n                ,scratch = Physics.scratchpad()\n                ,com = scratch.vector().zero()\n                ,b\n                ,pos\n                ,i\n                ,l = bodies && bodies.length\n                ,M = 0\n                ;\n\n            if ( !l ){\n                return scratch.done( this );\n            }\n\n            for ( i = 0; i < l; i++ ){\n                b = bodies[ i ];\n                // remove body from world if applicable\n                if ( b._world ){\n                    b._world.remove( b );\n                }\n                // add child\n                this.children.push( b );\n                // add child to geometry\n                this.geometry.addChild(\n                    b.geometry,\n                    new Physics.vector(b.offset)\n                        .rotate(b.state.angular.pos)\n                        .vadd(b.state.pos),\n                    b.state.angular.pos\n                );\n                // calc com contribution\n                pos = b.state.pos;\n                com.add( pos._[0] * b.mass, pos._[1] * b.mass );\n                M += b.mass;\n            }\n\n            // add mass\n            this.mass += M;\n            // com adjustment (assuming com is currently at (0,0) body coords)\n            com.mult( 1 / this.mass );\n\n            // shift the center of mass\n            this.offset.vsub( com );\n\n            // refresh view on next render\n            if ( this._world ){\n                this._world.one('render', function(){\n                    self.view = null;\n                });\n            }\n            this.recalc();\n\n            return scratch.done( this );\n        },\n\n        /**\n         * CompoundBody#clear() -> this\n         *\n         * Remove all children.\n         **/\n        clear: function(){\n\n            this._aabb = null;\n            this.moi = 0;\n            this.mass = 0;\n            this.offset.zero();\n            this.children = [];\n            this.geometry.clear();\n\n            return this;\n        },\n\n        /**\n         * CompoundBody#refreshGeometry() -> this\n         *\n         * If the children's positions change, `refreshGeometry()` should be called to fix the shape.\n         **/\n        refreshGeometry: function(){\n\n            this.geometry.clear();\n\n            for ( var i = 0, b, l = this.children.length; i < l; i++ ) {\n                b = this.children[ i ];\n                this.geometry.addChild( b.geometry, new Physics.vector(b.state.pos).vadd(b.offset), b.state.angular.pos );\n            }\n\n            return this;\n        },\n\n        // extended\n        recalc: function(){\n\n            parent.recalc.call(this);\n            // moment of inertia\n            var b\n                ,moi = 0\n                ;\n\n            for ( var i = 0, l = this.children.length; i < l; i++ ) {\n                b = this.children[ i ];\n                b.recalc();\n                // parallel axis theorem\n                moi += b.moi + b.mass * b.state.pos.normSq();\n            }\n\n            this.moi = moi;\n            return this;\n        }\n    };\n});\n\n\n// ---\n// inside: src/bodies/convex-polygon.js\n\n/*\n * @requires geometries/convex-polygon\n */\n /**\n  * class ConvexPolygonBody < Body\n  *\n  * Physics.body('convex-polygon')\n  *\n  * Body for convex polygons. The position of the body is the centroid of the polygon.\n  *\n  * Additional config options:\n  *\n  * - vertices: Array of [[Vectorish]] objects representing the polygon vertices in clockwise (or counterclockwise) order.\n  *\n  * Example:\n  *\n  * ```javascript\n  * var pentagon = Physics.body('convex-polygon', {\n  *     // place the centroid of the polygon at (300, 200)\n  *     x: 300,\n  *     y: 200,\n  *     // the centroid is automatically calculated and used to position the shape\n  *     vertices: [\n  *         { x: 0, y: -30 },\n  *         { x: -29, y: -9 },\n  *         { x: -18, y: 24 },\n  *         { x: 18, y: 24 },\n  *         { x: 29, y: -9 }\n  *     ]\n  * });\n  * ```\n  **/\nPhysics.body('convex-polygon', function( parent ){\n\n    var defaults = {\n\n    };\n\n    return {\n\n        // extended\n        init: function( options ){\n\n            // call parent init method\n            parent.init.call(this, options);\n\n            options = Physics.util.extend({}, defaults, options);\n\n            this.geometry = Physics.geometry('convex-polygon', {\n                vertices: options.vertices\n            });\n\n            this.recalc();\n        },\n\n        // extended\n        recalc: function(){\n            parent.recalc.call(this);\n            // moment of inertia\n            this.moi = Physics.geometry.getPolygonMOI( this.geometry.vertices );\n        }\n    };\n});\n\n\n// ---\n// inside: src/bodies/rectangle.js\n\n/*\n * @requires geometries/rectangle\n */\n /**\n  * class RectangleBody < Body\n  *\n  * Physics.body('rectangle')\n  *\n  * Body for rectangles. The position of the body is the centroid of the rectangle.\n  *\n  * Additional config options:\n  *\n  * - width: The width\n  * - height: The height\n  *\n  * Example:\n  *\n  * ```javascript\n  * var rect = Physics.body('rectangle', {\n  *     // place the centroid of the rectangle at (300, 200)\n  *     x: 300,\n  *     y: 200,\n  *     width: 30,\n  *     height: 40\n  * });\n  * ```\n  **/\nPhysics.body('rectangle', function( parent ){\n\n    var defaults = {\n\n    };\n\n    return {\n\n        // extended\n        init: function( options ){\n\n            // call parent init method\n            parent.init.call(this, options);\n\n            options = Physics.util.extend({}, defaults, options);\n\n            this.geometry = Physics.geometry('rectangle', {\n                width: options.width,\n                height: options.height\n            });\n\n            this.recalc();\n        },\n\n        // extended\n        recalc: function(){\n            var w = this.geometry.width;\n            var h = this.geometry.height;\n            parent.recalc.call(this);\n            // moment of inertia\n            this.moi = ( w*w + h*h ) * this.mass / 12;\n        }\n    };\n});\n\n\n// ---\n// inside: src/behaviors/attractor.js\n\n/** \n * class AttractorBehavior < Behavior\n *\n * `Physics.behavior('attractor')`.\n *\n * Attractor behavior attracts bodies to a specific point.\n *\n * Additional options include:\n * - pos: The position of the attraction point\n * - strength: How strong the attraction is (default: `1`)\n * - order: The power of the inverse distance (default: `2` because that is newtonian gravity... inverse square)\n * - max: The maximum distance in which to apply the attraction (default: Infinity)\n * - min: The minimum distance above which to apply the attraction (default: very small non-zero)\n **/\nPhysics.behavior('attractor', function( parent ){\n\n    var defaults = {\n\n        pos: null, // default to (0, 0)\n        // how strong the attraction is\n        strength: 1,\n        // power of the inverse distance (2 is inverse square)\n        order: 2,\n        // max distance to apply it to\n        max: false, // infinite\n        // min distance to apply it to\n        min: false // auto calc\n    };\n\n    return {\n\n        // extended\n        init: function( options ){\n\n            var self = this;\n            this._pos = new Physics.vector();\n            // call parent init method\n            parent.init.call( this );\n            this.options.defaults( defaults );\n            this.options.onChange(function( opts ){\n                self._maxDist = opts.max === false ? Infinity : opts.max;\n                self._minDist = opts.min ? opts.min : 10;\n                self.position( opts.pos );\n            });\n            this.options( options );\n        },\n\n        /**\n         * AttractorBehavior#position( [pos] ) -> this|Object\n         * - pos (Vectorish): The position to set\n         * + (Object): Returns the [[Vectorish]] position if no arguments provided\n         * + (this): For chaining\n         *\n         * Get or set the position of the attractor.\n         **/\n        position: function( pos ){\n            \n            var self = this;\n\n            if ( pos ){\n                this._pos.clone( pos );\n                return self;\n            }\n\n            return this._pos.values();\n        },\n        \n        // extended\n        behave: function( data ){\n\n            var bodies = this.getTargets()\n                ,body\n                ,order = this.options.order\n                ,strength = this.options.strength\n                ,minDist = this._minDist\n                ,maxDist = this._maxDist\n                ,scratch = Physics.scratchpad()\n                ,acc = scratch.vector()\n                ,norm\n                ,g\n                ;\n\n            for ( var j = 0, l = bodies.length; j < l; j++ ){\n                \n                body = bodies[ j ];\n\n                // clone the position\n                acc.clone( this._pos );\n                acc.vsub( body.state.pos );\n                // get the distance\n                norm = acc.norm();\n\n                if (norm > minDist && norm < maxDist){\n\n                    g = strength / Math.pow(norm, order);\n\n                    body.accelerate( acc.normalize().mult( g ) );\n                }\n            }\n\n            scratch.done();\n        }\n    };\n});\n\n\n// ---\n// inside: src/behaviors/body-collision-detection.js\n\n/**\n * class BodyCollisionDetectionBehavior < Behavior\n *\n * `Physics.behavior('body-collision-detection')`.\n *\n * Detect collisions of bodies.\n *\n * Publishes collision events to the world as a group of detected collisions per iteration.\n *\n * The event data will have a `.collisions` property that is an array of collisions of the form:\n *\n * ```javascript\n * {\n *     bodyA: // the first body\n *     bodyB: // the second body\n *     norm: // the normal vector (Vectorish)\n *     mtv: // the minimum transit vector. (the direction and length needed to extract bodyB from bodyA)\n *     pos: // the collision point relative to bodyA\n *     overlap: // the amount bodyA overlaps bodyB\n * }\n * ```\n *\n * Additional options include:\n * - check: channel to listen to for collision candidates (default: `collisions:candidates`). set to `true` to force check every pair of bodies in the world\n * - channel: channel to publish events to (default: `collisions:detected`)\n **/\nPhysics.behavior('body-collision-detection', function( parent ){\n\n    var supportFnStack = [];\n\n    /*\n     * getSupportFn( bodyA, bodyB ) -> Function\n     * - bodyA (Object): First body\n     * - bodyB (Object): Second body\n     * + (Function): The support function\n     *\n     * Get a general support function for use with GJK algorithm\n     */\n    var getSupportFn = function getSupportFn( bodyA, bodyB ){\n\n        var hash = Physics.util.pairHash( bodyA.uid, bodyB.uid )\n            ,fn = supportFnStack[ hash ]\n            ;\n\n        if ( !fn ){\n            fn = supportFnStack[ hash ] = function pairSupportFunction( searchDir ){\n\n                var tA = fn.tA\n                    ,tB = fn.tB\n                    ,vA = fn.tmpv1\n                    ,vB = fn.tmpv2\n                    ;\n\n                if ( fn.useCore ){\n                    vA = bodyA.geometry.getFarthestCorePoint( searchDir.rotateInv( tA ), vA, fn.marginA );\n                    vB = bodyB.geometry.getFarthestCorePoint( searchDir.rotate( tA ).rotateInv( tB ).negate(), vB, fn.marginB );\n                } else {\n                    vA = bodyA.geometry.getFarthestHullPoint( searchDir.rotateInv( tA ), vA );\n                    vB = bodyB.geometry.getFarthestHullPoint( searchDir.rotate( tA ).rotateInv( tB ).negate(), vB );\n                }\n\n                vA.vadd( bodyA.offset ).transform( tA );\n                vB.vadd( bodyB.offset ).transform( tB );\n                searchDir.negate().rotate( tB );\n\n                return {\n                    a: vA.values(),\n                    b: vB.values(),\n                    pt: vA.vsub( vB ).values()\n                };\n            };\n\n            // transforms for coordinate transformations\n            fn.tA = new Physics.transform();\n            fn.tB = new Physics.transform();\n\n            // temp vectors (used too frequently to justify scratchpad)\n            fn.tmpv1 = new Physics.vector();\n            fn.tmpv2 = new Physics.vector();\n        }\n\n        fn.useCore = false;\n        fn.margin = 0;\n        fn.tA.setRotation( bodyA.state.angular.pos ).setTranslation( bodyA.state.pos );\n        fn.tB.setRotation( bodyB.state.angular.pos ).setTranslation( bodyB.state.pos );\n        fn.bodyA = bodyA;\n        fn.bodyB = bodyB;\n\n        return fn;\n    };\n\n    /*\n     * checkGJK( bodyA, bodyB ) -> Object\n     * - bodyA (Object): First body\n     * - bodyB (Object): Second body\n     * + (Object): Collision result\n     *\n     * Use GJK algorithm to check arbitrary bodies for collisions\n     */\n    var checkGJK = function checkGJK( bodyA, bodyB ){\n\n        var scratch = Physics.scratchpad()\n            ,d = scratch.vector()\n            ,tmp = scratch.vector()\n            ,os = scratch.vector()\n            ,overlap\n            ,result\n            ,support\n            ,inc\n            ,collision = false\n            ,aabbA = bodyA.aabb()\n            ,dimA = Math.min( aabbA.hw, aabbA.hh )\n            ,aabbB = bodyB.aabb()\n            ,dimB = Math.min( aabbB.hw, aabbB.hh )\n            ;\n\n        // just check the overlap first\n        support = getSupportFn( bodyA, bodyB );\n        d.clone( bodyA.state.pos )\n            .vadd( bodyA.getGlobalOffset( os ) )\n            .vsub( bodyB.state.pos )\n            .vsub( bodyB.getGlobalOffset( os ) )\n            ;\n        result = Physics.gjk(support, d, true);\n\n        if ( result.overlap ){\n\n            // there is a collision. let's do more work.\n            collision = {\n                bodyA: bodyA,\n                bodyB: bodyB\n            };\n\n            // inc by 1% of the smallest dim.\n            inc = 1e-2 * Math.min(dimA || 1, dimB || 1);\n\n            // first get the min distance of between core objects\n            support.useCore = true;\n            support.marginA = 0;\n            support.marginB = 0;\n\n            // while there's still an overlap (or we don't have a positive distance)\n            // and the support margins aren't bigger than the shapes...\n            // search for the distance data\n            while ( (result.overlap || result.distance === 0) && (support.marginA < dimA || support.marginB < dimB) ){\n                if ( support.marginA < dimA ){\n                    support.marginA += inc;\n                }\n                if ( support.marginB < dimB ){\n                    support.marginB += inc;\n                }\n\n                result = Physics.gjk(support, d);\n            }\n\n            if ( result.overlap || result.maxIterationsReached ){\n                // This implementation can't deal with a core overlap yet\n                return scratch.done(false);\n            }\n\n            // calc overlap\n            overlap = (support.marginA + support.marginB) - result.distance;\n\n            if ( overlap <= 0 ){\n                return scratch.done(false);\n            }\n\n            collision.overlap = overlap;\n            // @TODO: for now, just let the normal be the mtv\n            collision.norm = d.clone( result.closest.b ).vsub( tmp.clone( result.closest.a ) ).normalize().values();\n            collision.mtv = d.mult( overlap ).values();\n            // get a corresponding hull point for one of the core points.. relative to body A\n            collision.pos = d.clone( collision.norm ).mult( support.marginA ).vadd( tmp.clone( result.closest.a ) ).vsub( bodyA.state.pos ).values();\n        }\n\n        return scratch.done( collision );\n    };\n\n    /*\n     * checkCircles( bodyA, bodyB ) -> Object\n     * - bodyA (Object): First body\n     * - bodyB (Object): Second body\n     * + (Object): Collision result\n     *\n     * Check two circles for collisions.\n     */\n    var checkCircles = function checkCircles( bodyA, bodyB ){\n\n        var scratch = Physics.scratchpad()\n            ,d = scratch.vector()\n            ,tmp = scratch.vector()\n            ,overlap\n            ,collision = false\n            ;\n\n        d.clone( bodyB.state.pos )\n            .vadd( bodyB.getGlobalOffset( tmp ) )\n            .vsub( bodyA.state.pos )\n            .vsub( bodyA.getGlobalOffset( tmp ) ) // save offset for later\n            ;\n        overlap = d.norm() - (bodyA.geometry.radius + bodyB.geometry.radius);\n\n        // hmm... they overlap exactly... choose a direction\n        if ( d.equals( Physics.vector.zero ) ){\n\n            d.set( 1, 0 );\n        }\n\n        if ( overlap <= 0 ){\n\n            collision = {\n                bodyA: bodyA,\n                bodyB: bodyB,\n                norm: d.normalize().values(),\n                mtv: d.mult( -overlap ).values(),\n                pos: d.mult( -bodyA.geometry.radius/overlap ).vadd( tmp ).values(),\n                overlap: -overlap\n            };\n        }\n\n        return scratch.done( collision );\n    };\n\n    /*\n     * checkPair( bodyA, bodyB[, disp] ) -> Object\n     * - bodyA (Object): First body\n     * - bodyB (Object): Second body\n     * + (Object): Collision result\n     *\n     * Check a pair for collisions\n     */\n    var checkPair = function checkPair( bodyA, bodyB ){\n\n        // filter out bodies that don't collide with each other\n        if (\n            ( bodyA.treatment === 'static' || bodyA.treatment === 'kinematic' ) &&\n            ( bodyB.treatment === 'static' || bodyB.treatment === 'kinematic' )\n        ){\n            return false;\n        }\n\n        if ( bodyA.geometry.name === 'circle' && bodyB.geometry.name === 'circle' ){\n\n            return checkCircles( bodyA, bodyB );\n\n        } else if ( bodyA.geometry.name === 'compound' || bodyB.geometry.name === 'compound' ){\n            // compound bodies are special. We can't use gjk because\n            // they could have concavities. so we do the pieces individually\n            var test = (bodyA.geometry.name === 'compound')\n                ,compound = test ? bodyA : bodyB\n                ,other = test ? bodyB : bodyA\n                ,cols\n                ,ch\n                ,ret = []\n                ,scratch = Physics.scratchpad()\n                ,vec = scratch.vector()\n                ,oldPos = scratch.vector()\n                ,otherAABB = other.aabb()\n                ,i\n                ,l\n                ;\n\n            for ( i = 0, l = compound.children.length; i < l; i++ ){\n\n                ch = compound.children[ i ];\n                // move body to fake position\n                oldPos.clone( ch.state.pos );\n                ch.offset.vadd( oldPos.vadd( compound.offset ).rotate( -ch.state.angular.pos ) );\n                ch.state.pos.clone( compound.state.pos );\n                ch.state.angular.pos += compound.state.angular.pos;\n\n                // check it if the aabbs overlap\n                if ( Physics.aabb.overlap(otherAABB, ch.aabb()) ){\n\n                    cols = checkPair( other, ch );\n\n                    if ( cols instanceof Array ){\n                        for ( var j = 0, c, ll = cols.length; j < ll; j++ ){\n                            c = cols[j];\n                            // set body to be the compound body\n                            if ( c.bodyA === ch ){\n                                c.bodyA = compound;\n                            } else {\n                                c.bodyB = compound;\n                            }\n                            ret.push( c );\n                        }\n\n                    } else if ( cols ) {\n                        // set body to be the compound body\n                        if ( cols.bodyA === ch ){\n                            cols.bodyA = compound;\n                        } else {\n                            cols.bodyB = compound;\n                        }\n                        ret.push( cols );\n                    }\n                }\n\n                // transform it back\n                ch.state.angular.pos -= compound.state.angular.pos;\n                ch.offset.vsub( oldPos );\n                ch.state.pos.clone( oldPos.rotate( ch.state.angular.pos ).vsub( compound.offset ) );\n            }\n\n            return scratch.done( ret );\n\n        } else {\n\n            return checkGJK( bodyA, bodyB );\n        }\n    };\n\n    var defaults = {\n\n        // channel to listen to for collision candidates\n        // set to \"true\" to force check every pair of bodies in the world\n        check: 'collisions:candidates',\n\n        // channel to publish events to\n        channel: 'collisions:detected'\n    };\n\n    return {\n\n        // extended\n        init: function( options ){\n\n            parent.init.call( this );\n            this.options.defaults( defaults );\n            this.options( options );\n        },\n\n        // extended\n        connect: function( world ){\n\n            if ( this.options.check === true ){\n\n                world.on( 'integrate:velocities', this.checkAll, this );\n\n            } else {\n\n                world.on( this.options.check, this.check, this );\n            }\n        },\n\n        // extended\n        disconnect: function( world ){\n\n            if ( this.options.check === true ){\n\n                world.off( 'integrate:velocities', this.checkAll, this );\n\n            } else {\n\n                world.off( this.options.check, this.check, this );\n            }\n        },\n\n        /** internal\n         * BodyCollisionDetectionBehavior#check( data )\n         * - data (Object): The event data\n         *\n         * Event callback to check pairs of objects that have been flagged by broad phase for possible collisions.\n         **/\n        check: function( data ){\n\n            var candidates = data.candidates\n                ,pair\n                ,targets = this.getTargets()\n                ,collisions = []\n                ,ret\n                ,prevContacts = this.prevContacts || {}\n                ,contactList = {}\n                ,pairHash = Physics.util.pairHash\n                ,hash\n                ;\n\n            for ( var i = 0, l = candidates.length; i < l; ++i ){\n\n                pair = candidates[ i ];\n\n                if ( targets === this._world._bodies ||\n                    // only check if the members are targeted by this behavior\n                    (Physics.util.indexOf( targets, pair.bodyA ) > -1) &&\n                    (Physics.util.indexOf( targets, pair.bodyB ) > -1)\n                ){\n                    ret = checkPair( pair.bodyA, pair.bodyB );\n\n                    if ( ret instanceof Array ){\n\n                        for ( var j = 0, r, ll = ret.length; j < ll; j++ ){\n                            r = ret[j];\n                            if ( r ){\n                                hash = pairHash( pair.bodyA.uid, pair.bodyB.uid );\n                                contactList[ hash ] = true;\n                                r.collidedPreviously = prevContacts[ hash ];\n                                collisions.push( r );\n                            }\n                        }\n\n                    } else if ( ret ){\n                        hash = pairHash( pair.bodyA.uid, pair.bodyB.uid );\n                        contactList[ hash ] = true;\n                        ret.collidedPreviously = prevContacts[ hash ];\n\n                        collisions.push( ret );\n                    }\n                }\n            }\n\n            this.prevContacts = contactList;\n\n            if ( collisions.length ){\n\n                this._world.emit( this.options.channel, {\n                    collisions: collisions\n                });\n            }\n        },\n\n        /** internal\n         * BodyCollisionDetectionBehavior#checkAll( data )\n         * - data (Object): The event data\n         *\n         * Event callback to check all pairs of objects in the list for collisions\n         **/\n        checkAll: function( data ){\n\n            var bodies = this.getTargets()\n                ,dt = data.dt\n                ,bodyA\n                ,bodyB\n                ,collisions = []\n                ,ret\n                ,prevContacts = this.prevContacts || {}\n                ,contactList = {}\n                ,pairHash = Physics.util.pairHash\n                ,hash\n                ;\n\n            for ( var j = 0, l = bodies.length; j < l; j++ ){\n\n                bodyA = bodies[ j ];\n\n                for ( var i = j + 1; i < l; i++ ){\n\n                    bodyB = bodies[ i ];\n\n                    ret = checkPair( bodyA, bodyB );\n\n                    if ( ret instanceof Array ){\n\n                        for ( var k = 0, r, ll = ret.length; k < ll; k++ ){\n                            r = ret[k];\n                            if ( r ){\n                                hash = pairHash( bodyA.uid, bodyB.uid );\n                                contactList[ hash ] = true;\n                                r.collidedPreviously = prevContacts[ hash ];\n                                collisions.push( r );\n                            }\n                        }\n\n                    } else if ( ret ){\n                        hash = pairHash( bodyA.uid, bodyB.uid );\n                        contactList[ hash ] = true;\n                        ret.collidedPreviously = prevContacts[ hash ];\n\n                        collisions.push( ret );\n                    }\n                }\n            }\n\n            this.prevContacts = contactList;\n\n            if ( collisions.length ){\n\n                this._world.emit( this.options.channel, {\n                    collisions: collisions\n                });\n            }\n        }\n    };\n\n});\n\n\n// ---\n// inside: src/behaviors/body-impulse-response.js\n\n/**\n * class BodyImpulseResponseBehavior < Behavior\n *\n * `Physics.behavior('body-impulse-response')`.\n *\n * Responds to collisions by applying impulses.\n *\n * Additional options include:\n * - check: channel to listen to for collisions (default: `collisions:detected`).\n * - mtvThreshold: apply partial extraction of bodies if the minimum transit vector is less than this value ( default: `1`)\n *   this will depend on your simulation characteristic length scale\n * - bodyExtractDropoff: every body overlap correction (underneith mtvThreshold) will only extract by this fraction (0..1). Helps with stablizing contacts. (default: `0.5`)\n * - forceWakeupAboveOverlapThreshold: force bodies to wake up if the overlap is above mtvThreshold ( default: `true` )\n **/\nPhysics.behavior('body-impulse-response', function( parent ){\n\n    var defaults = {\n        // channel to listen to for collisions\n        check: 'collisions:detected'\n        // apply partial extraction of bodies if the minimum transit vector is less than this value\n        // this will depend on your simulation characteristic length scale\n        ,mtvThreshold: 1\n        // every body overlap correction (underneith mtvThreshold) will only extract by this fraction (0..1)\n        // helps with stablizing contacts.\n        ,bodyExtractDropoff: 0.5\n        // force bodies to wake up if the overlap is above mtvThreshold\n        ,forceWakeupAboveOverlapThreshold: true\n    };\n\n    function getUid( b ){\n        return b.uid;\n    }\n\n    function clampMTV( totalV, mtv, into ){\n\n        var m, n;\n        n = mtv.norm();\n        m = n - totalV.proj( mtv );\n        m = Math.max( 0, Math.min( n, m ) );\n\n        if ( n === 0 ){\n            into.zero();\n        } else {\n            into.clone( mtv ).mult( m/n );\n        }\n\n        return into;\n    }\n\n    return {\n\n        // extended\n        init: function( options ){\n\n            parent.init.call( this );\n            this.options.defaults( defaults );\n            this.options( options );\n\n            this._bodyList = [];\n        },\n\n        // no applyTo method\n        applyTo: false,\n\n        // extended\n        connect: function( world ){\n\n            world.on( this.options.check, this.respond, this );\n        },\n\n        // extended\n        disconnect: function( world ){\n\n            world.off( this.options.check, this.respond, this );\n        },\n\n        /** internal\n         * BodyImpulseResponseBehavior#collideBodes( bodyA, bodyB, normal, point, mtrans, contact )\n         * - bodyA (Object): First Body\n         * - bodyB (Object): Second body\n         * - normal (Vector): Normal vector of the collision surface\n         * - point (Vector): Contact point of the collision\n         * - mtrans (Vector): Minimum transit vector that is the smallest displacement to separate the bodies\n         * - contact (Boolean): Are the bodies in resting contact relative to each other\n         *\n         * Collide two bodies by modifying their positions and velocities to conserve momentum\n         **/\n        collideBodies: function(bodyA, bodyB, normal, point, mtrans, contact){\n\n            var fixedA = bodyA.treatment === 'static' || bodyA.treatment === 'kinematic'\n                ,fixedB = bodyB.treatment === 'static' || bodyB.treatment === 'kinematic'\n                ,scratch = Physics.scratchpad()\n                // minimum transit vector for each body\n                ,mtv = scratch.vector().clone( mtrans )\n                ;\n\n            // do nothing if both are fixed\n            if ( fixedA && fixedB ){\n                scratch.done();\n                return;\n            }\n\n            // inverse masses and moments of inertia.\n            // give fixed bodies infinite mass and moi\n            var invMoiA = fixedA ? 0 : 1 / bodyA.moi\n                ,invMoiB = fixedB ? 0 : 1 / bodyB.moi\n                ,invMassA = fixedA ? 0 : 1 / bodyA.mass\n                ,invMassB = fixedB ? 0 : 1 / bodyB.mass\n                // coefficient of restitution between bodies\n                ,cor = bodyA.restitution * bodyB.restitution\n                // coefficient of friction between bodies\n                ,cof = bodyA.cof * bodyB.cof\n                // normal vector\n                ,n = scratch.vector().clone( normal )\n                // vector perpendicular to n\n                ,perp = scratch.vector().clone( n ).perp()\n                ,tmp = scratch.vector()\n                // collision point from A's center\n                ,rA = scratch.vector().clone( point )\n                // collision point from B's center\n                ,rB = scratch.vector().clone( point )\n                    .vadd( bodyA.state.pos )\n                    .vsub( bodyB.state.pos )\n                ,angVelA = bodyA.state.angular.vel\n                ,angVelB = bodyB.state.angular.vel\n                // relative velocity towards B at collision point\n                ,vAB = scratch.vector().clone( bodyB.state.vel )\n                        .vadd( tmp.clone(rB).perp().mult( angVelB ) )\n                        .vsub( bodyA.state.vel )\n                        .vsub( tmp.clone(rA).perp().mult( angVelA ) )\n                // break up components along normal and perp-normal directions\n                ,rAproj = rA.proj( n )\n                ,rAreg = rA.proj( perp )\n                ,rBproj = rB.proj( n )\n                ,rBreg = rB.proj( perp )\n                ,vproj = vAB.proj( n ) // projection of vAB along n\n                ,vreg = vAB.proj( perp ) // rejection of vAB along n (perp of proj)\n                ,impulse\n                ,sign\n                ,max\n                ,ratio\n                ,inContact = contact\n                ;\n\n            if ( contact ){\n\n                if ( fixedA ){\n\n                    clampMTV( bodyB._mtvTotal, mtv, tmp );\n                    bodyB._mtvTotal.vadd( tmp );\n\n                } else if ( fixedB ){\n\n                    clampMTV( bodyA._mtvTotal, mtv.negate(), tmp );\n                    bodyA._mtvTotal.vadd( tmp );\n                    mtv.negate();\n\n                } else {\n\n                    ratio = 0.5; //bodyA.mass / ( bodyA.mass + bodyB.mass );\n                    mtv.mult( ratio );\n                    clampMTV( bodyB._mtvTotal, mtv, tmp );\n                    bodyB._mtvTotal.vadd( tmp );\n\n                    mtv.clone( mtrans ).mult( ratio - 1 );\n                    clampMTV( bodyA._mtvTotal, mtv, tmp );\n                    bodyA._mtvTotal.vadd( tmp );\n\n                }\n            }\n\n            // if moving away from each other... don't bother.\n            if (vproj >= 0){\n                scratch.done();\n                return;\n            }\n\n            invMoiA = invMoiA === Infinity ? 0 : invMoiA;\n            invMoiB = invMoiB === Infinity ? 0 : invMoiB;\n\n            impulse =  - ((1 + cor) * vproj) / ( invMassA + invMassB + (invMoiA * rAreg * rAreg) + (invMoiB * rBreg * rBreg) );\n            // vproj += impulse * ( invMass + (invMoi * rreg * rreg) );\n            // angVel -= impulse * rreg * invMoi;\n\n\n            if ( fixedA ){\n\n                // apply impulse\n                bodyB.state.vel.vadd( n.mult( impulse * invMassB ) );\n                bodyB.state.angular.vel -= impulse * invMoiB * rBreg;\n\n            } else if ( fixedB ){\n\n                // apply impulse\n                bodyA.state.vel.vsub( n.mult( impulse * invMassA ) );\n                bodyA.state.angular.vel += impulse * invMoiA * rAreg;\n\n            } else {\n\n                // apply impulse\n                bodyB.state.vel.vadd( n.mult( impulse * invMassB ) );\n                bodyB.state.angular.vel -= impulse * invMoiB * rBreg;\n                bodyA.state.vel.vsub( n.mult( invMassA * bodyB.mass ) );\n                bodyA.state.angular.vel += impulse * invMoiA * rAreg;\n            }\n\n            // inContact = (impulse < 0.004);\n\n            // if we have friction and a relative velocity perpendicular to the normal\n            if ( cof && vreg ){\n\n\n                // TODO: here, we could first assume static friction applies\n                // and that the tangential relative velocity is zero.\n                // Then we could calculate the impulse and check if the\n                // tangential impulse is less than that allowed by static\n                // friction. If not, _then_ apply kinetic friction.\n\n                // instead we're just applying kinetic friction and making\n                // sure the impulse we apply is less than the maximum\n                // allowed amount\n\n                // maximum impulse allowed by kinetic friction\n                max = Math.abs(vreg) / ( invMassA + invMassB + (invMoiA * rAproj * rAproj) + (invMoiB * rBproj * rBproj) );\n                // the sign of vreg ( plus or minus 1 )\n                sign = vreg < 0 ? -1 : 1;\n\n                // get impulse due to friction\n                impulse = cof * Math.abs( impulse );\n                // constrain the impulse within the \"friction cone\" ( max < mu * impulse)\n                impulse = Math.min( impulse, max );\n                impulse *= sign;\n\n                if ( fixedA ){\n\n                    // apply frictional impulse\n                    bodyB.state.vel.vsub( perp.mult( impulse * invMassB ) );\n                    bodyB.state.angular.vel -= impulse * invMoiB * rBproj;\n\n                } else if ( fixedB ){\n\n                    // apply frictional impulse\n                    bodyA.state.vel.vadd( perp.mult( impulse * invMassA ) );\n                    bodyA.state.angular.vel += impulse * invMoiA * rAproj;\n\n                } else {\n\n                    // apply frictional impulse\n                    bodyB.state.vel.vsub( perp.mult( impulse * invMassB ) );\n                    bodyB.state.angular.vel -= impulse * invMoiB * rBproj;\n                    bodyA.state.vel.vadd( perp.mult( invMassA * bodyB.mass ) );\n                    bodyA.state.angular.vel += impulse * invMoiA * rAproj;\n                }\n            }\n\n            // wake up bodies if necessary\n            if ( bodyA.sleep() ){\n                bodyA.sleepCheck();\n            }\n            if ( bodyB.sleep() ){\n                bodyB.sleepCheck();\n            }\n\n            scratch.done();\n        },\n\n        // internal\n        _pushUniq: function( body ){\n            var idx = Physics.util.sortedIndex( this._bodyList, body, getUid );\n            if ( this._bodyList[ idx ] !== body ){\n                this._bodyList.splice( idx, 0, body );\n            }\n        },\n\n        /** internal\n         * BodyImpulseResponseBehavior#respond( data )\n         * - data (Object): event data\n         *\n         * Event callback to respond to collision data.\n         **/\n        respond: function( data ){\n\n            var self = this\n                ,col\n                ,collisions = data.collisions// Physics.util.shuffle(data.collisions)\n                ,i,l,b\n                ;\n\n            for ( i = 0, l = collisions.length; i < l; ++i ){\n\n                col = collisions[ i ];\n                // add bodies to list for later\n                this._pushUniq( col.bodyA );\n                this._pushUniq( col.bodyB );\n                // ensure they have mtv stat vectors\n                col.bodyA._mtvTotal = col.bodyA._mtvTotal || new Physics.vector();\n                col.bodyB._mtvTotal = col.bodyB._mtvTotal || new Physics.vector();\n                col.bodyA._oldmtvTotal = col.bodyA._oldmtvTotal || new Physics.vector();\n                col.bodyB._oldmtvTotal = col.bodyB._oldmtvTotal || new Physics.vector();\n\n                self.collideBodies(\n                    col.bodyA,\n                    col.bodyB,\n                    col.norm,\n                    col.pos,\n                    col.mtv,\n                    col.collidedPreviously\n                );\n            }\n\n            // apply mtv vectors from the average mtv vector\n            for ( i = 0, l = this._bodyList.length; i < l; ++i ){\n                b = this._bodyList.pop();\n                // clampMTV( b._oldmtvTotal, b._mtvTotal, b._mtvTotal );\n\n                if ( b._mtvTotal.normSq() < this.options.mtvThreshold ){\n                    b._mtvTotal.mult( this.options.bodyExtractDropoff );\n                } else if ( this.options.forceWakeupAboveOverlapThreshold ) {\n                    // wake up bodies if necessary\n                    b.sleep( false );\n                }\n\n                b.state.pos.vadd( b._mtvTotal );\n                b.state.old.pos.vadd( b._mtvTotal );\n                b._oldmtvTotal.swap( b._mtvTotal );\n                b._mtvTotal.zero();\n            }\n        }\n    };\n});\n\n\n// ---\n// inside: src/behaviors/constant-acceleration.js\n\n/** \n * class ConstantAccelerationBehavior < Behavior\n *\n * `Physics.behavior('constant-acceleration')`.\n *\n * Constant acceleration behavior.\n *\n * Basically the \"gravity\" behavior. Used to give \"earth-like gravity\" to the world.\n *\n * Additional options include:\n * - acc: The acceleration vector (Vectorish). (default: `{ x: 0, y: 0.0004 }`)\n **/\nPhysics.behavior('constant-acceleration', function( parent ){\n\n    var defaults = {\n\n        acc: { x : 0, y: 0.0004 }\n    };\n\n    return {\n\n        // extended\n        init: function( options ){\n\n            parent.init.call( this );\n            this.options.defaults( defaults );\n            this.options( options );\n\n            // extend options\n            this._acc = new Physics.vector();\n            this.setAcceleration( this.options.acc );\n            delete this.options.acc;\n        },\n\n        /**\n         * ConstantAccelerationBehavior#setAcceleration( acc ) -> this\n         * - acc (Vectorish): The acceleration vector\n         * \n         * Set the acceleration of the behavior.\n         **/\n        setAcceleration: function( acc ){\n\n            this._acc.clone( acc );\n            return this;\n        },\n\n        // extended\n        behave: function( data ){\n\n            var bodies = this.getTargets();\n\n            for ( var i = 0, l = bodies.length; i < l; ++i ){\n                \n                bodies[ i ].accelerate( this._acc );\n            }\n        }\n    };\n});\n\n// ---\n// inside: src/behaviors/edge-collision-detection.js\n\n/**\n * class EdgeCollisionDetectionBehavior < Behavior\n *\n * `Physics.behavior('edge-collision-detection')`.\n *\n * Used to detect collisions with the boundaries of an AABB.\n *\n * Additional options include:\n * - aabb: The [[Physics.aabb]] bounds to use as the constraining boundary\n * - restitution: The restitution of the boundary walls (default: `0.99`)\n * - cof: The coefficient of friction of the boundary walls (default: `1`)\n * - channel: The channel to publish collisions to. (default: 'collisions:detected')\n **/\nPhysics.behavior('edge-collision-detection', function( parent ){\n\n    /*\n     * checkGeneral( body, bounds, dummy ) -> Array\n     * - body (Body): The body to check\n     * - bounds (Physics.aabb): The boundary\n     * - dummy: (Body): The dummy body to publish as the static other body it collides with\n     * + (Array): The collision data\n     *\n     * Check if a body collides with the boundary\n     */\n    var checkGeneral = function checkGeneral( body, bounds, dummy ){\n\n        var overlap\n            ,aabb = body.aabb()\n            ,scratch = Physics.scratchpad()\n            ,offset = body.getGlobalOffset( scratch.vector() )\n            ,trans = scratch.transform()\n            ,dir = scratch.vector()\n            ,result = scratch.vector()\n            ,collision = false\n            ,collisions = []\n            ;\n\n        // right\n        overlap = (aabb.x + aabb.hw) - bounds.max.x;\n\n        if ( overlap >= 0 ){\n\n            dir.set( 1, 0 ).rotateInv( trans.setRotation( body.state.angular.pos ) );\n\n            collision = {\n                bodyA: body,\n                bodyB: dummy,\n                overlap: overlap,\n                norm: {\n                    x: 1,\n                    y: 0\n                },\n                mtv: {\n                    x: overlap,\n                    y: 0\n                },\n                pos: body.geometry.getFarthestHullPoint( dir, result ).rotate( trans ).vadd( offset ).values()\n            };\n\n            collisions.push(collision);\n        }\n\n        // bottom\n        overlap = (aabb.y + aabb.hh) - bounds.max.y;\n\n        if ( overlap >= 0 ){\n\n            dir.set( 0, 1 ).rotateInv( trans.setRotation( body.state.angular.pos ) );\n\n            collision = {\n                bodyA: body,\n                bodyB: dummy,\n                overlap: overlap,\n                norm: {\n                    x: 0,\n                    y: 1\n                },\n                mtv: {\n                    x: 0,\n                    y: overlap\n                },\n                pos: body.geometry.getFarthestHullPoint( dir, result ).rotate( trans ).vadd( offset ).values()\n            };\n\n            collisions.push(collision);\n        }\n\n        // left\n        overlap = bounds.min.x - (aabb.x - aabb.hw);\n\n        if ( overlap >= 0 ){\n\n            dir.set( -1, 0 ).rotateInv( trans.setRotation( body.state.angular.pos ) );\n\n            collision = {\n                bodyA: body,\n                bodyB: dummy,\n                overlap: overlap,\n                norm: {\n                    x: -1,\n                    y: 0\n                },\n                mtv: {\n                    x: -overlap,\n                    y: 0\n                },\n                pos: body.geometry.getFarthestHullPoint( dir, result ).rotate( trans ).vadd( offset ).values()\n            };\n\n            collisions.push(collision);\n        }\n\n        // top\n        overlap = bounds.min.y - (aabb.y - aabb.hh);\n\n        if ( overlap >= 0 ){\n\n            dir.set( 0, -1 ).rotateInv( trans.setRotation( body.state.angular.pos ) );\n\n            collision = {\n                bodyA: body,\n                bodyB: dummy,\n                overlap: overlap,\n                norm: {\n                    x: 0,\n                    y: -1\n                },\n                mtv: {\n                    x: 0,\n                    y: -overlap\n                },\n                pos: body.geometry.getFarthestHullPoint( dir, result ).rotate( trans ).vadd( offset ).values()\n            };\n\n            collisions.push(collision);\n        }\n\n        scratch.done();\n        return collisions;\n    };\n\n    /*\n     * checkEdgeCollide( body, bounds, dummy ) -> Array\n     * - body (Body): The body to check\n     * - bounds (Physics.aabb): The boundary\n     * - dummy: (Body): The dummy body to publish as the static other body it collides with\n     * + (Array): The collision data\n     *\n     * Check if a body collides with the boundary\n     */\n    var checkEdgeCollide = function checkEdgeCollide( body, bounds, dummy ){\n\n        return checkGeneral( body, bounds, dummy );\n    };\n\n    var defaults = {\n\n        aabb: null,\n        restitution: 0.99,\n        cof: 1.0,\n        channel: 'collisions:detected'\n    };\n\n    return {\n\n        // extended\n        init: function( options ){\n\n            parent.init.call( this );\n            this.options.defaults( defaults );\n            this.options( options );\n\n            this.setAABB( this.options.aabb );\n            this.restitution = this.options.restitution;\n\n            this.body = Physics.body('point', {\n                treatment: 'static',\n                restitution: this.options.restitution,\n                cof: this.options.cof\n            });\n        },\n\n        /**\n         * EdgeCollisionDetectionBehavior#setAABB( aabb ) -> this\n         * - aabb (Physics.aabb): The aabb to use as the boundary\n         *\n         * Set the boundaries of the edge.\n         **/\n        setAABB: function( aabb ){\n\n            if (!aabb) {\n                throw 'Error: aabb not set';\n            }\n\n            this._edges = {\n                min: {\n                    x: (aabb.x - aabb.hw),\n                    y: (aabb.y - aabb.hh)\n                },\n                max: {\n                    x: (aabb.x + aabb.hw),\n                    y: (aabb.y + aabb.hh)\n                }\n            };\n\n            return this;\n        },\n\n        // extended\n        connect: function( world ){\n\n            world.on( 'integrate:positions', this.checkAll, this, 2 );\n        },\n\n        // extended\n        disconnect: function( world ){\n\n            world.off( 'integrate:positions', this.checkAll, this, 2 );\n        },\n\n        /** internal\n         * EdgeCollisionDetectionBehavior#checkAll( data )\n         * - data (Object): Event data\n         *\n         * Event callback to check all bodies for collisions with the edge\n         **/\n        checkAll: function( data ){\n\n            var bodies = this.getTargets()\n                ,dt = data.dt\n                ,body\n                ,collisions = []\n                ,ret\n                ,bounds = this._edges\n                ,dummy = this.body\n                ,prevContacts = this.prevContacts || {}\n                ,contactList = {}\n                ,pairHash = Physics.util.pairHash\n                ,hash\n                ;\n\n            for ( var i = 0, l = bodies.length; i < l; i++ ){\n\n                body = bodies[ i ];\n\n                // only detect dynamic bodies\n                if ( body.treatment === 'dynamic' ){\n\n                    ret = checkEdgeCollide( body, bounds, dummy );\n\n                    if ( ret ){\n                        hash = pairHash( body.uid, dummy.uid );\n\n                        for ( var j = 0, ll = ret.length; j < ll; j++ ){\n                            contactList[ hash ] = true;\n                            ret[ j ].collidedPreviously = prevContacts[ hash ];\n                        }\n\n                        collisions.push.apply( collisions, ret );\n                    }\n                }\n            }\n\n            this.prevContacts = contactList;\n\n            if ( collisions.length ){\n\n                this._world.emit( this.options.channel, {\n                    collisions: collisions\n                });\n            }\n        }\n    };\n\n});\n\n\n// ---\n// inside: src/behaviors/interactive.js\n\n/**\n * class InteractiveBehavior < Behavior\n *\n * `Physics.behavior('interactive')`.\n *\n * User interaction helper.\n *\n * Used to get mouse/touch events and add grab interactions.\n *\n * Additional options include:\n * - el: The element of the renderer. What you input as the `el` for the renderer.\n * - moveThrottle: The min time between move events (default: `10`).\n * - minVel: The minimum velocity clamp [[Vectorish]] (default: { x: -5, y: -5 }) to restrict velocity a user can give to a body\n * - maxVel: The maximum velocity clamp [[Vectorish]] (default: { x: 5, y: 5 }) to restrict velocity a user can give to a body\n *\n * The behavior also triggers the following events on the world:\n * ```javascript\n * // a body has been grabbed\n * world.on('interact:grab', function( data ){\n *     data.x; // the x coord\n *     data.y; // the y coord\n *     data.body; // the body that was grabbed\n * });\n * // no body was grabbed, but the renderer area was clicked, or touched\n * world.on('interact:poke', function( data ){\n *     data.x; // the x coord\n *     data.y; // the y coord\n * });\n * // when a mouse or pointer moves\n * world.on('interact:move', function( data ){\n *     data.x; // the x coord\n *     data.y; // the y coord\n *     data.body; // the grabbed body that was moved (if applicable)\n * });\n * // when the viewport is released (mouseup, touchend)\n * world.on('interact:release', function( data ){\n *     data.x; // the x coord\n *     data.y; // the y coord\n *     data.body; // the body that was grabbed (if applicable)\n * });\n * ```\n *\n * The behavior also sets body.isGrabbed = true for any grabbed bodies while they are grabbed.\n **/\nPhysics.behavior('interactive', function( parent ){\n\n    if ( !document ){\n        // must be in node environment\n        return {};\n    }\n\n    var defaults = {\n            // the element to monitor\n            el: null,\n            // time between move events\n            moveThrottle: 1000 / 100 | 0,\n            // minimum velocity clamp\n            minVel: { x: -5, y: -5 },\n            // maximum velocity clamp\n            maxVel: { x: 5, y: 5 }\n        }\n        ,getElementOffset = function( el ){\n            var curleft = 0\n                ,curtop = 0\n                ;\n\n            if (el.offsetParent) {\n                do {\n                    curleft += el.offsetLeft;\n                    curtop += el.offsetTop;\n                } while (el = el.offsetParent);\n            }\n\n            return { left: curleft, top: curtop };\n        }\n        ;\n\n    return {\n        // extended\n        init: function( options ){\n\n            var self = this;\n\n            // call parent init method\n            parent.init.call( this );\n            this.options.defaults( defaults );\n            this.options( options );\n\n            // vars\n            this.bodyData = {};\n            this.bodyDataByUID = {};\n\n            this.el = typeof this.options.el === 'string' ? document.getElementById(this.options.el) : this.options.el;\n\n            if ( !this.el ){\n                throw \"No DOM element specified\";\n            }\n\n            // init events\n            // when there are multiple touchdowns, grab is usually called separately for each,\n            // but we loop through e.changedTouches just in case\n            self.grab = function grab( e ){\n                var pos\n                    ,body\n                    ,touchId\n                    ,touch\n                    ,offset\n                    ,data\n                    ,touchIndex\n                    ,l\n                    ;\n\n                if ( self._world ){\n\n                    // Adjust for PointerEvent and older browsers\n                    if ( !e.changedTouches ) {\n                        e.changedTouches = [ e ];\n                    }\n\n                    offset = getElementOffset( e.target );\n\n                    for ( touchIndex = 0, l = e.changedTouches.length; touchIndex < l; touchIndex++) {\n                        touch = e.changedTouches[touchIndex];\n                        touchId = touch.identifier || touch.pointerId || \"mouse\";\n                        pos = { idx: touchId, x: touch.pageX - offset.left, y: touch.pageY - offset.top };\n                        body = self._world.findOne({ $at: new Physics.vector( pos ), $in: self.getTargets() });\n\n                        if ( body ){\n                            // we're trying to grab a body\n\n                            // fix the body in place\n                            body.state.vel.zero();\n                            body.state.angular.vel = 0;\n                            body.isGrabbed = true;\n                            // remember the currently grabbed bodies\n                            data = self.bodyData[touchId] || {};\n                            data.body = body;\n                            // wake the body up\n                            body.sleep( false );\n                            data.time = Physics.util.ticker.now();\n\n                            // if we're grabbing the same body twice we don't want to remember the wrong treatment.\n                            data.treatment = self.bodyDataByUID[ body.uid ] ? self.bodyDataByUID[ body.uid ].treatment : body.treatment;\n                            // change its treatment but remember its old treatment\n                            body.treatment = 'kinematic';\n                            // remember the click/touch offset\n                            data.pos = data.pos || new Physics.vector();\n                            data.pos.clone( pos );\n\n                            data.offset = data.offset || new Physics.vector();\n                            data.offset.clone( pos ).vsub( body.state.pos );\n                            // init touchPointsOld here, too, so we don't have to do it in \"move\"\n                            data.oldPos = data.oldPos || new Physics.vector();\n                            data.oldPos.clone( pos );\n\n                            pos.body = body;\n                            self.bodyData[touchId] = data;\n                            self.bodyDataByUID[ body.uid ] = data;\n                            self._world.emit('interact:grab', pos);\n\n                        } else {\n\n                            self._world.emit('interact:poke', pos);\n                        }\n                    }\n                }\n            };\n\n            // when there are multiple touchdowns, move is called once\n            // and e.changedTouches will have one or more touches in it\n            self.move = Physics.util.throttle(function move( e ){\n                var pos\n                    ,state\n                    ,body\n                    ,touchId\n                    ,touch\n                    ,offset\n                    ,data\n                    ,touchIndex\n                    ,l\n                    ;\n\n                if ( self._world ){\n\n                    // Adjust for PointerEvent and older browsers\n                    if ( !e.changedTouches ) {\n                        e.changedTouches = [ e ];\n                    }\n\n                    offset = getElementOffset( self.el );\n\n                    for ( touchIndex = 0, l = e.changedTouches.length; touchIndex < l; touchIndex++) {\n                        touch = e.changedTouches[touchIndex];\n                        touchId = touch.identifier || touch.pointerId || \"mouse\";\n                        pos = { idx: touchId, x: touch.pageX - offset.left, y: touch.pageY - offset.top };\n                        data = self.bodyData[touchId];\n\n                        if ( data ){\n                            body = data.body;\n\n                            // wake the body up\n                            body.sleep( false );\n                            data.time = Physics.util.ticker.now();\n\n                            // set old mouse position\n                            data.oldPos.clone( data.pos );\n                            // get new mouse position\n                            data.pos.clone( pos );\n\n                            pos.body = body;\n                        }\n\n                        self._world.emit('interact:move', pos);\n                    }\n                }\n\n            }, self.options.moveThrottle);\n\n            // when there are multiple touchups, release is called once\n            // and e.changedTouches will have one or more touches in it\n            self.release = function release( e ){\n                var pos\n                    ,body\n                    ,touchId\n                    ,touch\n                    ,offset\n                    ,data\n                    ,dt\n                    ,touchIndex\n                    ,l\n                    ;\n\n                if ( self._world ){\n\n                    // Adjust for PointerEvent and older browsers\n                    if ( !e.changedTouches ) {\n                        e.changedTouches = [ e ];\n                    }\n\n                    for ( touchIndex = 0, l = e.changedTouches.length; touchIndex < l; touchIndex++) {\n                        offset = getElementOffset( self.el );\n                        touch = e.changedTouches[touchIndex];\n                        touchId = touch.identifier || touch.pointerId || \"mouse\";\n                        pos = { idx: touchId, x: touch.pageX - offset.left, y: touch.pageY - offset.top };\n                        data = self.bodyData[touchId];\n\n                        // release the body\n                        if ( data ){\n                            body = data.body;\n                            // wake the body up\n                            body.sleep( false );\n                            // get new mouse position\n                            data.pos.clone( pos );\n\n                            dt = Math.max(Physics.util.ticker.now() - data.time, self.options.moveThrottle);\n                            body.treatment = data.treatment;\n                            // calculate the release velocity\n                            body.state.vel.clone( data.pos ).vsub( data.oldPos ).mult( 1 / dt );\n                            // make sure it's not too big\n                            body.state.vel.clamp( self.options.minVel, self.options.maxVel );\n\n                            body.isGrabbed = false;\n                            pos.body = body;\n\n                            delete body.isGrabbed;\n                        }\n\n                        // emit before we delete the vars in case\n                        // the listeners need the body\n                        self._world.emit('interact:release', pos);\n\n                        // remove vars\n                        delete self.bodyData[touchId];\n                    }\n                }\n            };\n        },\n\n        // extended\n        connect: function( world ){\n\n            // subscribe the .behave() method to the position integration step\n            world.on('integrate:positions', this.behave, this);\n\n            if ( window.PointerEvent ) {\n\n                this.el.addEventListener('pointerdown', this.grab);\n                window.addEventListener('pointermove', this.move);\n                window.addEventListener('pointerup', this.release);\n\n            } else {\n\n                this.el.addEventListener('mousedown', this.grab);\n                this.el.addEventListener('touchstart', this.grab);\n\n                window.addEventListener('mousemove', this.move);\n                window.addEventListener('touchmove', this.move);\n\n                window.addEventListener('mouseup', this.release);\n                window.addEventListener('touchend', this.release);\n\n            }\n        },\n\n        // extended\n        disconnect: function( world ){\n\n            // unsubscribe when disconnected\n            world.off('integrate:positions', this.behave, this);\n\n            if ( window.PointerEvent ) {\n\n                this.el.removeEventListener('pointerdown', this.grab);\n                window.removeEventListener('pointermove', this.move);\n                window.removeEventListener('pointerup', this.release);\n\n            } else {\n\n                this.el.removeEventListener('mousedown', this.grab);\n                this.el.removeEventListener('touchstart', this.grab);\n\n                window.removeEventListener('mousemove', this.move);\n                window.removeEventListener('touchmove', this.move);\n\n                window.removeEventListener('mouseup', this.release);\n                window.removeEventListener('touchend', this.release);\n\n            }\n        },\n\n        // extended\n        behave: function( data ){\n\n            var self = this\n                ,state\n                ,dt = Math.max(data.dt, self.options.moveThrottle)\n                ,body\n                ,d\n                ;\n\n            // if we have one or more bodies grabbed, we need to move them to the new mouse/finger positions.\n            // we'll do this by adjusting the velocity so they get there at the next step\n            for ( var touchId in self.bodyData ) {\n                d = self.bodyData[touchId];\n                body = d.body;\n                state = body.state;\n                state.vel.clone( d.pos ).vsub( d.offset ).vsub( state.pos ).mult( 1 / dt );\n            }\n        }\n    };\n});\n\n\n// ---\n// inside: src/behaviors/newtonian.js\n\n/**\n * class NewtonianBehavior < Behavior\n *\n * `Physics.behavior('newtonian')`.\n *\n * Newtonian attraction between bodies (inverse square law).\n *\n * Additional options include:\n * - strength: The strength of the interaction between bodies. (default: `1`)\n * - max: The maximum distance between bodies at which to apply the behavior. (default: `false`... infinite)\n * - min: The minimum distance between bodies at which to apply the behavior. (default: `false`... autocalculate)\n **/\nPhysics.behavior('newtonian', function( parent ){\n\n    var defaults = {\n\n        strength: 1,\n        // max distance to apply it to\n        max: false, // infinite\n        // min distance to apply it to\n        min: false // auto calc\n    };\n\n    return {\n\n        // extended\n        init: function( options ){\n\n            var self = this;\n            // call parent init method\n            parent.init.call( this );\n            this.options.defaults( defaults );\n            this.options.onChange(function( opts ){\n                self._maxDistSq = opts.max === false ? Infinity : opts.max * opts.max;\n                self._minDistSq = opts.min ? opts.min * opts.min : 100 * opts.strength;\n            });\n            this.options( options );\n        },\n\n        calcPotential: function( posA, posB, out ){\n\n            var strength = this.options.strength\n                ,minDistSq = this._minDistSq\n                ,maxDistSq = this._maxDistSq\n                ,normsq\n                ,g\n                ,pos\n                ;\n\n            pos = out || new Physics.vector();\n\n            // clone the position\n            pos.clone( posB ).vsub( posA );\n            // get the square distance\n            normsq = pos.normSq();\n\n            if (normsq > minDistSq && normsq < maxDistSq){\n\n                g = strength / normsq;\n                return pos.normalize().mult( g );\n            }\n\n            return pos.zero();\n        },\n\n        // extended\n        behave: function( data ){\n\n            var bodies = this.getTargets()\n                ,body\n                ,other\n                ,scratch = Physics.scratchpad()\n                ,potential = scratch.vector()\n                ,comp\n                ,bodyA\n                ,bodyB\n                ,posA = scratch.vector()\n                ,posB = scratch.vector()\n                ,i, j, k, m, l, ll, lll\n                ;\n\n            for ( j = 0, l = bodies.length; j < l; j++ ){\n\n                body = bodies[ j ];\n\n                for ( i = j + 1; i < l; i++ ){\n\n                    other = bodies[ i ];\n\n                    if ( body.name === 'compound' ){\n                        comp = body;\n                    } else if ( other.name === 'compound' ){\n                        comp = other;\n                        other = body;\n                    }\n\n                    if ( comp ){\n                        if ( other.name === 'compound' ){\n                            for ( k = 0, ll = comp.children.length; k < ll; k++ ){\n                                bodyA = comp.children[ k ];\n                                comp.toWorldCoords( posA.clone( bodyA.state.pos ).vadd( comp.offset ) );\n                                for ( m = 0, lll = other.children.length; m < lll; m++ ){\n                                    bodyB = other.children[ m ];\n                                    other.toWorldCoords( posB.clone( bodyB.state.pos ).vadd( other.offset ) );\n                                    this.calcPotential( posA, posB, potential );\n                                    comp.accelerate( potential.mult( bodyB.mass ) );\n                                    other.accelerate( potential.mult( bodyA.mass/bodyB.mass ).negate() );\n                                }\n                            }\n                        } else {\n                            for ( k = 0, ll = comp.children.length; k < ll; k++ ){\n                                bodyA = comp.children[ k ];\n                                comp.toWorldCoords( posA.clone( bodyA.state.pos ).vadd( comp.offset ) );\n                                this.calcPotential( posA, other.state.pos, potential );\n                                comp.accelerate( potential.mult( other.mass ) );\n                                other.accelerate( potential.mult( bodyA.mass/other.mass ).negate() );\n                            }\n                        }\n\n                    } else {\n\n                        this.calcPotential( body.state.pos, other.state.pos, potential );\n                        body.accelerate( potential.mult( other.mass ) );\n                        other.accelerate( potential.mult( body.mass/other.mass ).negate() );\n                    }\n\n                    comp = null;\n                }\n            }\n\n            scratch.done();\n        }\n    };\n});\n\n\n// ---\n// inside: src/behaviors/sweep-prune.js\n\n/**\n * class SweepPruneBehavior < Behavior\n *\n * `Physics.behavior('sweep-prune')`.\n *\n * Sweep and Prune implementation for broad phase collision detection.\n *\n * This massively improves the speed of collision detection. It's set up to always be used with [[BodyCollisionDetection]], and [[BodyImpulseResponse]].\n *\n * Additional options include:\n * - channel: The channel to publish collision candidates to. (default: `collisions:candidates`)\n **/\nPhysics.behavior('sweep-prune', function( parent ){\n\n    var uid = 1;\n\n    // Get a unique numeric id for internal use\n    var getUniqueId = function getUniqueId(){\n\n        return uid++;\n    };\n\n    // add z: 2 to get this to work in 3D\n    var dof = { x: 0, y: 1 }; // degrees of freedom\n    // change to \"3\" to get it to work in 3D\n    var maxDof = 2;\n\n    var pairHash = Physics.util.pairHash;\n\n    return {\n\n        // extended\n        init: function( options ){\n\n            parent.init.call( this );\n            this.options.defaults({\n                channel: 'collisions:candidates' //default channel\n            });\n            this.options( options );\n\n            this.encounters = [];\n            this.candidates = [];\n\n            this.clear();\n        },\n\n        /**\n         * SweepPruneBehavior#clear()\n         *\n         * Refresh tracking data\n         **/\n        clear: function(){\n\n            this.tracked = [];\n            this.pairs = []; // pairs selected as candidate collisions by broad phase\n            this.intervalLists = []; // stores lists of aabb projection intervals to be sorted\n\n            // init intervalLists\n            for ( var xyz = 0; xyz < maxDof; ++xyz ){\n\n                this.intervalLists[ xyz ] = [];\n            }\n        },\n\n        // extended\n        connect: function( world ){\n\n            world.on( 'add:body', this.trackBody, this );\n            world.on( 'remove:body', this.untrackBody, this );\n            world.on( 'integrate:positions', this.sweep, this, 1 );\n\n            // add current bodies\n            var bodies = world.getBodies();\n            for ( var i = 0, l = bodies.length; i < l; ++i ){\n\n                this.trackBody({ body: bodies[ i ] });\n            }\n        },\n\n        // extended\n        disconnect: function( world ){\n\n            world.off( 'add:body', this.trackBody, this );\n            world.off( 'remove:body', this.untrackBody, this );\n            world.off( 'integrate:positions', this.sweep, this, 1 );\n            this.clear();\n        },\n\n        /** internal\n         * SweepPruneBehavior#broadPhase() -> Array\n         * + (Array): The candidate data of overlapping aabbs\n         *\n         * Execute the broad phase and get candidate collisions\n         **/\n        broadPhase: function(){\n\n            this.updateIntervals();\n            this.sortIntervalLists();\n\n            if ( this._world ){\n                this._world.emit('sweep-prune:intervals', this.intervalLists);\n            }\n\n            return this.checkOverlaps();\n        },\n\n        /** internal\n         * SweepPruneBehavior#sortIntervalLists()\n         *\n         * Simple insertion sort for each axis\n         **/\n        sortIntervalLists: function(){\n\n            var list\n                ,len\n                ,i\n                ,hole\n                ,bound\n                ,boundVal\n                ,left\n                ,leftVal\n                ,axis\n                ;\n\n            // for each axis...\n            for ( var xyz = 0; xyz < maxDof; ++xyz ){\n\n                // get the intervals for that axis\n                list = this.intervalLists[ xyz ];\n                i = 0;\n                len = list.length;\n                axis = xyz;\n\n                // for each interval bound...\n                while ( (++i) < len ){\n\n                    // store bound\n                    bound = list[ i ];\n                    boundVal = bound.val.get( axis );\n                    hole = i;\n\n                    left = list[ hole - 1 ];\n                    leftVal = left && left.val.get( axis );\n\n                    // while others are greater than bound...\n                    while (\n                        hole > 0 &&\n                        (\n                            leftVal > boundVal ||\n                            // if it's an equality, only move it over if\n                            // the hole was created by a minimum\n                            // and the previous is a maximum\n                            // so that we detect contacts also\n                            leftVal === boundVal &&\n                            ( left.type && !bound.type )\n                        )\n                    ) {\n\n                        // move others greater than bound to the right\n                        list[ hole ] = left;\n                        hole--;\n                        left = list[ hole - 1 ];\n                        leftVal = left && left.val.get( axis );\n                    }\n\n                    // insert bound in the hole\n                    list[ hole ] = bound;\n                }\n            }\n        },\n\n        /** internal\n         * SweepPruneBehavior#getPair( tr1, tr2, doCreate ) -> Object\n         * - tr1 (Object): First tracker\n         * - tr2 (Object): Second tracker\n         * - doCreate (Boolean): Create if not found\n         * + (Object): Pair object or null if not found\n         *\n         * Get a pair object for the tracker objects\n         **/\n        getPair: function(tr1, tr2, doCreate){\n\n            var hash = pairHash( tr1.id, tr2.id );\n\n            if ( hash === false ){\n                return null;\n            }\n\n            var c = this.pairs[ hash ];\n\n            if ( !c ){\n\n                if ( !doCreate ){\n                    return null;\n                }\n\n                c = this.pairs[ hash ] = {\n                    bodyA: tr1.body,\n                    bodyB: tr2.body,\n                    flag: 1\n                };\n            }\n\n            if ( doCreate){\n                c.flag = 1;\n            }\n\n            return c;\n        },\n\n        // getPair: function(tr1, tr2, doCreate){\n\n        //     var hash = Math.min(tr1.id, tr2.id) // = pairHash( tr1.id, tr2.id )\n        //         ,other = Math.max(tr1.id, tr2.id)\n        //         ,first\n        //         ,c\n        //         ;\n\n        //     if ( hash === false ){\n        //         return null;\n        //     }\n\n        //     first = this.pairs[ hash ];\n\n        //     if ( !first ){\n        //         if ( !doCreate ){\n        //             return null;\n        //         }\n\n        //         first = this.pairs[ hash ] = [];\n        //     }\n\n        //     c = first[ other ];\n\n        //     if ( !c ){\n\n        //         if ( !doCreate ){\n        //             return null;\n        //         }\n\n        //         c = first[ other ] = {\n        //             bodyA: tr1.body,\n        //             bodyB: tr2.body,\n        //             flag: 1\n        //         };\n        //     }\n\n        //     return c;\n        // },\n\n        /** internal\n         * SweepPruneBehavior#checkOverlaps() -> Array\n         * + (Array): List of candidate collisions\n         *\n         * Check each axis for overlaps of bodies AABBs\n         **/\n        checkOverlaps: function(){\n\n            var isX\n                ,hash\n                ,tr1\n                ,tr2\n                ,bound\n                ,list\n                ,len\n                ,i\n                ,j\n                ,c\n                // determine which axis is the last we need to check\n                ,collisionFlag = 1 << (dof.z + 1) << (dof.y + 1) << (dof.x + 1)\n                ,encounters = this.encounters\n                ,enclen = 0\n                ,candidates = this.candidates\n                ;\n\n            Physics.util.clearArray( encounters );\n            Physics.util.clearArray( candidates );\n\n            for ( var xyz = 0; xyz < maxDof; ++xyz ){\n\n                // is the x coord\n                isX = (xyz === 0);\n                // get the interval list for this axis\n                list = this.intervalLists[ xyz ];\n\n                // for each interval bound\n                for ( i = 0, len = list.length; i < len; i++ ){\n\n                    bound = list[ i ];\n                    tr1 = bound.tracker;\n\n                    if ( bound.type ){\n\n                        // is a max\n\n                        j = enclen;\n\n                        for ( j = enclen - 1; j >= 0; j-- ){\n\n                            tr2 = encounters[ j ];\n\n                            // if they are the same tracked interval\n                            if ( tr2 === tr1 ){\n\n                                // remove the interval from the encounters list\n                                // faster than .splice()\n                                if ( j < enclen - 1 ) {\n\n                                    encounters[ j ] = encounters.pop();\n\n                                } else {\n\n                                    // encountered a max right after a min... no overlap\n                                    encounters.pop();\n                                }\n\n                                enclen--;\n\n                            } else {\n\n                                // check if we have flagged this pair before\n                                // if it's the x axis, create a pair\n                                c = this.getPair( tr1, tr2, isX );\n\n                                if ( c && c.flag < collisionFlag ){\n\n                                    // if it's greater than the axis index, set the flag\n                                    // to = 0.\n                                    // if not, increment the flag by one.\n                                    c.flag = c.flag << (xyz + 1);\n\n                                    // c.flag will equal collisionFlag\n                                    // if we've incremented the flag\n                                    // enough that all axes are overlapping\n                                    if ( c.flag === collisionFlag ){\n\n                                        // overlaps on all axes.\n                                        // add it to possible collision\n                                        // candidates list for narrow phase\n\n                                        candidates.push( c );\n                                    }\n                                }\n                            }\n                        }\n\n                    } else {\n\n                        // is a min\n                        // just add this minimum to the encounters list\n                        enclen = encounters.push( tr1 );\n                    }\n                }\n            }\n\n            return candidates;\n        },\n\n        /** internal\n         * SweepPruneBehavior#updateIntervals()\n         *\n         * Update position intervals on each axis\n         **/\n        updateIntervals: function(){\n\n            var tr\n                ,intr\n                ,aabb\n                ,list = this.tracked\n                ,i = list.length\n                ;\n\n            // for all tracked bodies\n            while ( (--i) >= 0 ){\n\n                tr = list[ i ];\n                intr = tr.interval;\n                aabb = tr.body.aabb();\n\n                // copy the position (plus or minus) the aabb half-dimensions\n                // into the min/max intervals\n                intr.min.val.clone( aabb ).sub( aabb.hw, aabb.hh );\n                intr.max.val.clone( aabb ).add( aabb.hw, aabb.hh );\n            }\n        },\n\n        /** internal\n         * SweepPruneBehavior#trackBody( data )\n         * - data (Object): Event data\n         *\n         * Event callback to add body to list of those tracked by sweep and prune\n         **/\n        trackBody: function( data ){\n\n            var body = data.body\n                ,tracker = {\n\n                    id: getUniqueId(),\n                    body: body\n                }\n                ,intr = {\n\n                    min: {\n                        type: false, //min\n                        val: new Physics.vector(),\n                        tracker: tracker\n                    },\n\n                    max: {\n                        type: true, //max\n                        val: new Physics.vector(),\n                        tracker: tracker\n                    }\n                }\n                ;\n\n            tracker.interval = intr;\n            this.tracked.push( tracker );\n\n            for ( var xyz = 0; xyz < maxDof; ++xyz ){\n\n                this.intervalLists[ xyz ].push( intr.min, intr.max );\n            }\n        },\n\n        /** internal\n         * SweepPruneBehavior#untrackBody( data )\n         * - data (Object): Event data\n         *\n         * Event callback to remove body from list of those tracked\n         **/\n        untrackBody: function( data ){\n\n            var body = data.body\n                ,list\n                ,minmax\n                ,trackedList = this.tracked\n                ,tracker\n                ,count\n                ;\n\n            for ( var i = 0, l = trackedList.length; i < l; ++i ){\n\n                tracker = trackedList[ i ];\n\n                if ( tracker.body === body ){\n\n                    // remove the tracker at this index\n                    trackedList.splice(i, 1);\n\n                    for ( var xyz = 0; xyz < maxDof; ++xyz ){\n\n                        count = 0;\n                        list = this.intervalLists[ xyz ];\n\n                        for ( var j = 0, m = list.length; j < m; ++j ){\n\n                            minmax = list[ j ];\n\n                            if ( minmax === tracker.interval.min || minmax === tracker.interval.max ){\n\n                                // remove interval from list\n                                list.splice(j, 1);\n                                j--;\n                                l--;\n\n                                if (count > 0){\n                                    break;\n                                }\n\n                                count++;\n                            }\n                        }\n                    }\n\n                    break;\n                }\n            }\n        },\n\n        /** internal\n         * SweepPruneBehavior#sweep( data )\n         * - data (Object): Event data\n         *\n         * Event callback to sweep and publish event if any candidate collisions are found\n         **/\n        sweep: function( data ){\n\n            var self = this\n                ,candidates\n                ;\n\n            candidates = self.broadPhase();\n\n            if ( candidates.length ){\n\n                this._world.emit( this.options.channel, {\n                    candidates: candidates\n                });\n            }\n        }\n    };\n});\n\n\n// ---\n// inside: src/behaviors/verlet-constraints.js\n\n/**\n * class VerletConstraintsBehavior < Behavior\n *\n * `Physics.behavior('verlet-constraints')`.\n *\n * Verlet constraints manager.\n *\n * Handles distance constraints, and angle constraints\n *\n * Additional options include:\n * - iterations: The number of iterations to take to relax the constraints. (default: `2`)\n **/\nPhysics.behavior('verlet-constraints', function( parent ){\n\n    var TWOPI = 2 * Math.PI;\n\n    var defaults = {\n\n        // number of iterations to resolve constraints\n        iterations: 2\n    };\n\n    return {\n\n        // extended\n        init: function( options ){\n\n            parent.init.call( this );\n            this.options.defaults( defaults );\n            this.options( options );\n\n            this._distanceConstraints = [];\n            this._angleConstraints = [];\n        },\n\n        // extended\n        connect: function( world ){\n\n            var intg = world.integrator();\n\n            if ( intg && intg.name.indexOf('verlet') < 0 ){\n\n                throw 'The rigid constraint manager needs a world with a \"verlet\" compatible integrator.';\n            }\n\n            world.on('integrate:positions', this.resolve, this);\n        },\n\n        // extended\n        disconnect: function( world ){\n\n            world.off('integrate:positions', this.resolve, this);\n        },\n\n        /**\n         * VerletConstraintsBehavior#drop() -> this\n         *\n         * Remove all constraints\n         **/\n        drop: function(){\n\n            // drop the current constraints\n            this._distanceConstraints = [];\n            this._angleConstraints = [];\n            return this;\n        },\n\n        /**\n         * VerletConstraintsBehavior#distanceConstraint( bodyA, bodyB[, stiffness, targetLength] ) -> Object\n         * - bodyA (Body): First body\n         * - bodyB (Body): Second body\n         * - stiffness (Number): A number between 0 and 1 that represents the stiffness of the constraint. Defaults to: `0.5`\n         * - targetLength (Number): Target length. defaults to current distance between the bodies\n         * + (Object): The constraint data object\n         *\n         * Constrain two bodies to a target relative distance.\n         *\n         * Returns constraint data that can be used to remove the constraint later.\n         *\n         * - `.bodyA` and `.bodyB` are references to the bodies\n         * - `.type` is the type of constraint\n         * - `.id` is the string ID of the constraint\n         * - `.stiffness` is the stiffness\n         * - `.targetLength` is the target length\n         **/\n        distanceConstraint: function( bodyA, bodyB, stiffness, targetLength ){\n\n            var cst;\n\n            if (!bodyA || !bodyB){\n\n                return false;\n            }\n\n            cst = {\n                id: Physics.util.uniqueId('dis-constraint'),\n                type: 'dis',\n                bodyA: bodyA,\n                bodyB: bodyB,\n                stiffness: stiffness || 0.5,\n                targetLength: targetLength || bodyB.state.pos.dist( bodyA.state.pos )\n            };\n\n            cst.targetLengthSq = cst.targetLength * cst.targetLength;\n\n            this._distanceConstraints.push( cst );\n            return cst;\n        },\n\n        /**\n         * VerletConstraintsBehavior#angleConstraint( bodyA, bodyB, bodyC[, stiffness, targetAngle] ) -> Object\n         * - bodyA (Body): First body\n         * - bodyB (Body): Second body\n         * - bodyC (Body): Third body\n         * - stiffness (Number): A number between 0 and 1 that represents the stiffness of the constraint. Defaults to: `0.5`\n         * - targetAngle (Number): Target angle. Defaults to the current angle between bodies\n         * + (Object): The constraint data object\n         *\n         * Constrain three bodies to a target relative angle\n         *\n         * Returns constraint data that can be used to remove the constraint later.\n         *\n         * - `.bodyA`, `.bodyB`, and `.bodyC` are references to the bodies\n         * - `.type` is the type of constraint\n         * - `.id` is the string ID of the constraint\n         * - `.stiffness` is the stiffness\n         * - `.targetAngle` is the target angle\n         **/\n        angleConstraint: function( bodyA, bodyB, bodyC, stiffness, targetAngle ){\n\n            var cst;\n\n            if (!bodyA || !bodyB){\n\n                return false;\n            }\n\n            cst = {\n                id: Physics.util.uniqueId('ang-constraint'),\n                type: 'ang',\n                bodyA: bodyA,\n                bodyB: bodyB,\n                bodyC: bodyC,\n                stiffness: stiffness || 0.5,\n                targetAngle: targetAngle || bodyB.state.pos.angle2( bodyA.state.pos, bodyC.state.pos )\n            };\n\n            this._angleConstraints.push( cst );\n            return cst;\n        },\n\n        /**\n         * VerletConstraintsBehavior#remove( constraintData ) -> this\n         * VerletConstraintsBehavior#remove( constraintId ) -> this\n         * - constraintData (Object): The constraint data returned when creating a constraint\n         * - constraintId (String): The constraint id\n         *\n         * Remove a constraint\n         **/\n        remove: function( cstrOrId ){\n\n            var constraints\n                ,type\n                ,isObj\n                ,i\n                ,l\n                ;\n\n            isObj = Physics.util.isObject( cstrOrId );\n\n            type = (isObj) ? cstrOrId.type : cstrOrId.substr(0, 3);\n            constraints = ( type === 'ang' ) ? this._angleConstraints : this._distanceConstraints;\n\n            if ( isObj ){\n\n                for ( i = 0, l = constraints.length; i < l; ++i ){\n\n                    if ( constraints[ i ] === cstrOrId ){\n\n                        constraints.splice( i, 1 );\n                        return this;\n                    }\n                }\n            } else {\n\n                for ( i = 0, l = constraints.length; i < l; ++i ){\n\n                    if ( constraints[ i ].id === cstrOrId ){\n\n                        constraints.splice( i, 1 );\n                        return this;\n                    }\n                }\n            }\n\n            return this;\n        },\n\n        /** internal\n         * VerletConstraintsBehavior#resolveAngleConstraints( coef )\n         * - coef (Number): Coefficient for this resolution phase\n         *\n         * Resolve angle constraints.\n         **/\n        resolveAngleConstraints: function( coef ){\n\n            var constraints = this._angleConstraints\n                ,scratch = Physics.scratchpad()\n                ,trans = scratch.transform()\n                ,con\n                ,ang\n                ,corr\n                ,proportion\n                ,invMassSum\n                ;\n\n            for ( var i = 0, l = constraints.length; i < l; ++i ){\n\n                con = constraints[ i ];\n\n                ang = con.bodyB.state.pos.angle2( con.bodyA.state.pos, con.bodyC.state.pos );\n                corr = ang - con.targetAngle;\n\n                if (!corr){\n\n                    continue;\n\n                } else if (corr <= -Math.PI){\n\n                    corr += TWOPI;\n\n                } else if (corr >= Math.PI){\n\n                    corr -= TWOPI;\n                }\n\n                trans.setTranslation( con.bodyB.state.pos );\n\n                corr *= -coef * con.stiffness;\n\n                if ( con.bodyA.treatment === 'dynamic' && con.bodyB.treatment === 'dynamic' && con.bodyC.treatment === 'dynamic' ){\n                    invMassSum = 1 / (con.bodyA.mass + con.bodyB.mass + con.bodyC.mass);\n                }\n\n                if ( con.bodyA.treatment === 'dynamic' ){\n\n                    if ( con.bodyB.treatment === 'dynamic' && con.bodyC.treatment === 'dynamic' ){\n\n                        ang = corr * (con.bodyB.mass + con.bodyC.mass) * invMassSum;\n\n                    } else if ( con.bodyB.treatment !== 'dynamic' ){\n\n                        ang = corr * con.bodyC.mass / ( con.bodyC.mass + con.bodyA.mass );\n\n                    } else {\n\n                        ang = corr * con.bodyB.mass / ( con.bodyB.mass + con.bodyA.mass );\n                    }\n\n\n                    trans.setRotation( ang );\n                    con.bodyA.state.pos.translateInv( trans );\n                    con.bodyA.state.pos.rotate( trans );\n                    con.bodyA.state.pos.translate( trans );\n                }\n\n                if ( con.bodyC.treatment === 'dynamic' ){\n\n                    if ( con.bodyA.treatment === 'dynamic' && con.bodyB.treatment === 'dynamic' ){\n\n                        ang = -corr * (con.bodyB.mass + con.bodyA.mass) * invMassSum;\n\n                    } else if ( con.bodyB.treatment !== 'dynamic' ){\n\n                        ang = -corr * con.bodyA.mass / ( con.bodyC.mass + con.bodyA.mass );\n\n                    } else {\n\n                        ang = -corr * con.bodyB.mass / ( con.bodyB.mass + con.bodyC.mass );\n                    }\n\n                    trans.setRotation( ang );\n                    con.bodyC.state.pos.translateInv( trans );\n                    con.bodyC.state.pos.rotate( trans );\n                    con.bodyC.state.pos.translate( trans );\n                }\n\n                if ( con.bodyB.treatment === 'dynamic' ){\n\n                    if ( con.bodyA.treatment === 'dynamic' && con.bodyC.treatment === 'dynamic' ){\n\n                        ang = corr * (con.bodyA.mass + con.bodyC.mass) * invMassSum;\n\n                    } else if ( con.bodyA.treatment !== 'dynamic' ){\n\n                        ang = corr * con.bodyC.mass / ( con.bodyC.mass + con.bodyB.mass );\n\n                    } else {\n\n                        ang = corr * con.bodyA.mass / ( con.bodyA.mass + con.bodyC.mass );\n                    }\n\n                    // ang = corr;\n\n                    trans.setRotation( ang ).setTranslation( con.bodyA.state.pos );\n                    con.bodyB.state.pos.translateInv( trans );\n                    con.bodyB.state.pos.rotate( trans );\n                    con.bodyB.state.pos.translate( trans );\n\n                    trans.setTranslation( con.bodyC.state.pos );\n                    con.bodyB.state.pos.translateInv( trans );\n                    con.bodyB.state.pos.rotateInv( trans );\n                    con.bodyB.state.pos.translate( trans );\n                }\n\n                con.bodyA.sleepCheck();\n                con.bodyB.sleepCheck();\n                con.bodyC.sleepCheck();\n            }\n\n            scratch.done();\n        },\n\n        /** internal\n         * VerletConstraintsBehavior#resolveDistanceConstraints( coef )\n         * - coef (Number): Coefficient for this resolution phase\n         *\n         * Resolve distance constraints.\n         **/\n        resolveDistanceConstraints: function( coef ){\n\n            var constraints = this._distanceConstraints\n                ,scratch = Physics.scratchpad()\n                ,BA = scratch.vector()\n                ,con\n                ,len\n                ,corr\n                ,proportion\n                ;\n\n            for ( var i = 0, l = constraints.length; i < l; ++i ){\n\n                con = constraints[ i ];\n\n                // move constrained bodies to target length based on their\n                // mass proportions\n                BA.clone( con.bodyB.state.pos ).vsub( con.bodyA.state.pos );\n                len = BA.normSq() || Math.random() * 0.0001;\n                corr = coef * con.stiffness * ( len - con.targetLengthSq ) / len;\n\n                BA.mult( corr );\n                proportion = (con.bodyA.treatment !== 'dynamic' || con.bodyB.treatment !== 'dynamic') ? 1 : con.bodyB.mass / (con.bodyA.mass + con.bodyB.mass);\n\n                if ( con.bodyA.treatment === 'dynamic' ){\n\n                    if ( con.bodyB.treatment === 'dynamic' ){\n                        BA.mult( proportion );\n                    }\n\n                    con.bodyA.state.pos.vadd( BA );\n\n                    if ( con.bodyB.treatment === 'dynamic' ){\n                        BA.mult( 1 / proportion );\n                    }\n                }\n\n                if ( con.bodyB.treatment === 'dynamic' ){\n\n                    if ( con.bodyA.treatment === 'dynamic' ){\n                        BA.mult( 1 - proportion );\n                    }\n\n                    con.bodyB.state.pos.vsub( BA );\n                }\n\n                con.bodyA.sleepCheck();\n                con.bodyB.sleepCheck();\n            }\n\n            scratch.done();\n        },\n\n        /** internal\n         * VerletConstraintsBehavior#shuffleConstraints()\n         *\n         * Mix up the constraints.\n         **/\n        shuffleConstraints: function(){\n\n            this._distanceConstraints = Physics.util.shuffle( this._distanceConstraints );\n            this._angleConstraints = Physics.util.shuffle( this._angleConstraints );\n        },\n\n        /** internal\n         * VerletConstraintsBehavior#resolve()\n         *\n         * Resolve all constraints.\n         **/\n        resolve: function(){\n\n            var its = this.options.iterations\n                ,coef = 1 / its\n                ;\n\n            for (var i = 0; i < its; i++){\n\n                // this.shuffleConstraints();\n                this.resolveDistanceConstraints( coef );\n                this.resolveAngleConstraints( coef );\n            }\n        },\n\n        /**\n         * VerletConstraintsBehavior#getConstraints() -> Object\n         * + (Object): The object containing copied arrays of the constraints\n         *\n         * Get all constraints.\n         **/\n        getConstraints: function(){\n\n            return {\n                distanceConstraints: [].concat(this._distanceConstraints),\n                angleConstraints: [].concat(this._angleConstraints)\n            };\n        }\n    };\n});\n\n\n// ---\n// inside: src/integrators/improved-euler.js\n\nPhysics.integrator('improved-euler', function( parent ){\n\n    return {\n        /**\n         * class ImprovedEuler < Integrator\n         *\n         * `Physics.integrator('improved-euler')`.\n         *\n         * The improved euler integrator.\n         **/\n\n        // extended\n        init: function( options ){\n\n            // call parent init\n            parent.init.call(this, options);\n        },\n\n        // extended\n        integrateVelocities: function( bodies, dt ){\n\n            // half the timestep squared\n            var drag = 1 - this.options.drag\n                ,body = null\n                ,state\n                ;\n\n            for ( var i = 0, l = bodies.length; i < l; ++i ){\n\n                body = bodies[ i ];\n                state = body.state;\n\n                // only integrate if the body isn't fixed\n                if ( body.treatment !== 'static' && !body.sleep( dt ) ){\n\n                    // Inspired from https://github.com/soulwire/Coffee-Physics\n                    // @licence MIT\n                    //\n                    // x += (v * dt) + (a * 0.5 * dt * dt)\n                    // v += a * dt\n\n\n                    // Scale force to mass.\n                    // state.acc.mult( body.massInv );\n\n                    // Remember velocity for future use.\n                    state.old.vel.clone( state.vel );\n\n                    // remember original acc\n                    state.old.acc.clone( state.acc );\n\n                    // Update velocity first so we can reuse the acc vector.\n                    // a *= dt\n                    // v += a ...\n                    state.vel.vadd( state.acc.mult( dt ) );\n\n                    // Apply \"air resistance\".\n                    if ( drag ){\n\n                        state.vel.mult( drag );\n                    }\n\n                    // Reset accel\n                    state.acc.zero();\n\n                    //\n                    // Angular components\n                    //\n\n                    state.old.angular.vel = state.angular.vel;\n                    state.angular.vel += state.angular.acc * dt;\n                    state.angular.acc = 0;\n\n                } else {\n                    // set the velocity and acceleration to zero!\n                    state.vel.zero();\n                    state.acc.zero();\n                    state.angular.vel = 0;\n                    state.angular.acc = 0;\n                }\n            }\n        },\n\n        // extended\n        integratePositions: function( bodies, dt ){\n\n            // half the timestep squared\n            var halfdtdt = 0.5 * dt * dt\n                ,body = null\n                ,state\n                // use cached vector instances\n                // so we don't need to recreate them in a loop\n                ,scratch = Physics.scratchpad()\n                ,vel = scratch.vector()\n                ,angVel\n                ;\n\n            for ( var i = 0, l = bodies.length; i < l; ++i ){\n\n                body = bodies[ i ];\n                state = body.state;\n\n                // only integrate if the body isn't fixed\n                if ( body.treatment !== 'static' && !body.sleep() ){\n\n\n                    // Store previous location.\n                    state.old.pos.clone( state.pos );\n\n                    // Update position.\n                    // ...\n                    // oldV *= dt\n                    // a *= 0.5 * dt\n                    // x += oldV + a\n                    vel.clone( state.old.vel );\n                    state.pos.vadd( vel.mult( dt ) ).vadd( state.old.acc.mult( halfdtdt ) );\n\n                    state.old.acc.zero();\n\n                    //\n                    // Angular components\n                    //\n\n                    state.old.angular.pos = state.angular.pos;\n                    state.angular.pos += state.old.angular.vel * dt + state.old.angular.acc * halfdtdt;\n                    state.old.angular.acc = 0;\n\n                }\n            }\n\n            scratch.done();\n        }\n    };\n});\n\n\n// ---\n// inside: src/integrators/velocity-verlet-alt.js\n\nPhysics.integrator('velocity-verlet-alt', function( parent ){\n\n    // for this integrator we need to know if the object has been integrated before\n    // so let's add a mixin to bodies\n\n    Physics.body.mixin({\n\n        started: function( val ){\n            if ( val !== undefined ){\n                this._started = true;\n            }\n\n            return !!this._started;\n        }\n    });\n\n\n    return {\n        /**\n         * class VelocityVerlet < Integrator\n         *\n         * `Physics.integrator('velocity-verlet')`.\n         *\n         * The velocity-verlet integrator.\n         **/\n\n        // extended\n        init: function( options ){\n\n            // call parent init\n            parent.init.call(this, options);\n        },\n\n        // extended\n        integrateVelocities: function( bodies, dt ){\n\n            // half the timestep\n            var dtdt = dt * dt\n                ,drag = 1 - this.options.drag\n                ,body = null\n                ,state\n                ;\n\n            for ( var i = 0, l = bodies.length; i < l; ++i ){\n\n                body = bodies[ i ];\n                state = body.state;\n\n                // only integrate if the body isn't static\n                if ( body.treatment !== 'static' ){\n\n                    // v = v_prev + 0.5 * (a_prev + a) * dt\n                    // x = x_prev + v_prev * dt + 0.5 * a_prev * dt * dt\n\n                    // use the velocity in vel if the velocity has been changed manually\n                    if ( !body.started() ){\n\n                        // Set old vals on first integration\n                        state.old.acc.clone( state.acc );\n                        state.old.acc.mult( dt );\n                        state.old.vel.clone( state.vel ).vsub( state.old.acc );\n                        state.old.acc.mult( 1/dt );\n                    }\n\n                    // Apply \"air resistance\".\n                    if ( drag ){\n\n                        state.vel.mult( drag );\n                    }\n\n                    // Apply acceleration\n                    // v += 0.5 * (a_prev + a) * dt\n                    state.vel.vadd( state.old.acc.vadd( state.acc ).mult( 0.5 * dt ) );\n\n                    // Reset accel\n                    // state.acc.zero();\n\n                    //\n                    // Angular components\n                    //\n\n                    if ( !body.started() ){\n\n                        // Set old vals on first integration\n                        state.old.angular.acc = state.angular.acc;\n                        state.old.angular.vel = state.angular.vel - state.old.angular.acc * dt;\n                    }\n\n                    state.angular.vel += 0.5 * (state.angular.acc + state.old.angular.acc) * dt;\n                    state.angular.acc = 0;\n\n                    body.started( true );\n\n                } else {\n                    // set the velocity and acceleration to zero!\n                    state.vel.zero();\n                    state.acc.zero();\n                    state.angular.vel = 0;\n                    state.angular.acc = 0;\n                }\n            }\n        },\n\n        // extended\n        integratePositions: function( bodies, dt ){\n\n            // half the timestep\n            var dtdt = dt * dt\n                ,body = null\n                ,state\n                ;\n\n            for ( var i = 0, l = bodies.length; i < l; ++i ){\n\n                body = bodies[ i ];\n                state = body.state;\n\n                // only integrate if the body isn't static\n                if ( body.treatment !== 'static' ){\n\n                    // x = x_prev + v_prev * dt + 0.5 * a_prev * dt * dt\n\n                    // Store old position.\n                    // xold = x\n                    state.old.pos.clone( state.pos );\n\n                    state.old.vel.mult( dt );\n                    state.old.acc.mult( 0.5 * dtdt );\n                    state.pos.vadd( state.old.vel ).vadd( state.old.acc );\n\n                    // store calculated velocity\n                    state.old.vel.clone( state.vel );\n\n                    // store old acc\n                    state.old.acc.clone( state.acc );\n\n                    // Reset accel\n                    state.acc.zero();\n\n                    //\n                    // Angular components\n                    //\n                    state.old.angular.pos = state.angular.pos;\n\n                    state.angular.pos += state.angular.vel * dt + 0.5 * state.old.angular.acc * dtdt;\n                    state.old.angular.vel = state.angular.vel;\n                    state.old.angular.acc = state.angular.acc;\n                    state.angular.acc = 0;\n                }\n            }\n        }\n    };\n});\n\n\n// ---\n// inside: src/integrators/velocity-verlet.js\n\nPhysics.integrator('velocity-verlet', function( parent ){\n\n    // for this integrator we need to know if the object has been integrated before\n    // so let's add a mixin to bodies\n\n    Physics.body.mixin({\n\n        started: function( val ){\n            if ( val !== undefined ){\n                this._started = true;\n            }\n\n            return !!this._started;\n        }\n    });\n\n\n    return {\n        /**\n         * class VelocityVerlet < Integrator\n         *\n         * `Physics.integrator('velocity-verlet')`.\n         *\n         * The velocity-verlet integrator.\n         **/\n\n        // extended\n        init: function( options ){\n\n            // call parent init\n            parent.init.call(this, options);\n        },\n\n        /**\n         * Integrator#integrate( bodies, dt ) -> this\n         * - bodies (Array): List of bodies to integrate\n         * - dt (Number): Timestep size\n         *\n         * Integrate bodies by timestep.\n         *\n         * Will emit `integrate:velocities` and `integrate:positions`\n         * events on the world.\n         **/\n        integrate: function( bodies, dt ){\n\n            var world = this._world;\n\n            this.integratePositions( bodies, dt );\n\n            if ( world ){\n                world.emit('integrate:positions', {\n                    bodies: bodies,\n                    dt: dt\n                });\n            }\n\n            this.integrateVelocities( bodies, dt );\n\n            if ( world ){\n                world.emit('integrate:velocities', {\n                    bodies: bodies,\n                    dt: dt\n                });\n            }\n\n            return this;\n        },\n\n        // extended\n        integrateVelocities: function( bodies, dt ){\n\n            // half the timestep\n            var dtdt = dt * dt\n                ,drag = 1 - this.options.drag\n                ,body = null\n                ,state\n                ;\n\n            for ( var i = 0, l = bodies.length; i < l; ++i ){\n\n                body = bodies[ i ];\n                state = body.state;\n\n                // only integrate if the body isn't static\n                if ( body.treatment !== 'static' && !body.sleep() ){\n\n                    // v = v_prev + 0.5 * (a_prev + a) * dt\n                    // x = x_prev + v_prev * dt + 0.5 * a_prev * dt * dt\n\n                    // Apply \"air resistance\".\n                    if ( drag ){\n\n                        state.vel.mult( drag );\n                    }\n\n                    // Apply acceleration\n                    // v += 0.5 * (a_prev + a) * dt\n                    state.old.vel.clone( state.vel );\n                    state.vel.vadd( state.old.acc.vadd( state.acc ).mult( 0.5 * dt ) );\n\n                    // Reset accel\n                    state.old.acc.clone( state.acc );\n                    state.acc.zero();\n\n                    //\n                    // Angular components\n                    //\n\n                    state.old.angular.vel = state.angular.vel;\n                    state.old.angular.acc = state.angular.acc;\n\n                    state.angular.vel += 0.5 * (state.angular.acc + state.old.angular.acc) * dt;\n\n                    state.angular.acc = 0;\n\n                    body.started( true );\n\n                } else {\n                    // set the velocity and acceleration to zero!\n                    state.vel.zero();\n                    state.acc.zero();\n                    state.angular.vel = 0;\n                    state.angular.acc = 0;\n                }\n            }\n        },\n\n        // extended\n        integratePositions: function( bodies, dt ){\n\n            // half the timestep\n            var dtdt = dt * dt\n                ,body = null\n                ,state\n                ;\n\n            for ( var i = 0, l = bodies.length; i < l; ++i ){\n\n                body = bodies[ i ];\n                state = body.state;\n\n                // only integrate if the body isn't static\n                if ( body.treatment !== 'static' && !body.sleep( dt ) ){\n\n                    // x = x_prev + v_prev * dt + 0.5 * a_prev * dt * dt\n\n                    // use the velocity in vel if the velocity has been changed manually\n                    if ( !body.started() ){\n\n                        // Set old vals on first integration\n                        state.old.acc.clone( state.acc );\n                        state.old.acc.mult( dt );\n                        state.old.vel.clone( state.vel ).vsub( state.old.acc );\n                        state.old.acc.mult( 1/dt );\n                    }\n\n                    // Store old position.\n                    // xold = x\n                    state.old.pos.clone( state.pos );\n\n                    state.old.vel.mult( dt );\n                    state.old.acc.mult( 0.5 * dtdt );\n                    state.pos.vadd( state.old.vel ).vadd( state.old.acc );\n\n                    // revert\n                    state.old.vel.mult( 1/dt );\n                    state.old.acc.mult( 2 / dtdt );\n\n                    //\n                    // Angular components\n                    //\n\n                    if ( !body.started() ){\n\n                        // Set old vals on first integration\n                        state.old.angular.acc = state.angular.acc;\n                        state.old.angular.vel = state.angular.vel - state.old.angular.acc * dt;\n                    }\n\n                    state.old.angular.pos = state.angular.pos;\n\n                    state.angular.pos += state.angular.vel * dt + 0.5 * state.old.angular.acc * dtdt;\n                }\n            }\n        }\n    };\n});\n\n\n// ---\n// inside: src/renderers/canvas.js\n\n/**\n * class CanvasRenderer < Renderer\n *\n * Physics.renderer('canvas')\n *\n * Renderer that uses HTMLCanvas to render the world bodies.\n *\n * Additional config options:\n *\n * - metaEl: HTMLElement to write meta information like FPS and IPF into. (default: autogenerated)\n * - offset: Offset the shapes by this amount. (default: `{ x: 0, y: 0 }`)\n * - styles: Styles to use to draw the shapes. (see below)\n *\n * The styles property should contain _default_ styles for each shape you want to draw.\n *\n * Example:\n *\n * ```javascript\n * styles: {\n *\n *    'circle' : {\n *        strokeStyle: '#542437',\n *        lineWidth: 1,\n *        fillStyle: '#542437',\n *        angleIndicator: 'white'\n *    },\n *\n *    'convex-polygon' : {\n *        strokeStyle: '#542437',\n *        lineWidth: 1,\n *        fillStyle: '#542437',\n *        angleIndicator: 'white'\n *    }\n * }\n * ```\n *\n * Styles can also be defined on a per-body basis. Use the \"styles\" property for a body:\n *\n * Example:\n *\n * ```javascript\n * Physics.body('circle', {\n *     // ...\n *     styles: {\n *        strokeStyle: '#542437',\n *        lineWidth: 1,\n *        fillStyle: '#542437',\n *        angleIndicator: 'white'\n *    }\n * });\n * ```\n *\n * You can also define an image to use for a body:\n *\n * Example:\n *\n * ```javascript\n * Physics.body('circle', {\n *     // ...\n *     styles: {\n *        src: 'path/to/image.jpg',\n *        width: 40,\n *        height: 50\n *    }\n * });\n * ```\n **/\nPhysics.renderer('canvas', function( proto ){\n\n    if ( !document ){\n        // must be in node environment\n        return {};\n    }\n\n    var Pi2 = Math.PI * 2\n        // helper to create new dom elements\n        ,newEl = function( node, content ){\n            var el = document.createElement(node || 'div');\n            if (content){\n                el.innerHTML = content;\n            }\n            return el;\n        }\n        ,colors = {\n            white: '#fff'\n            ,violet: '#542437'\n            ,blue: '#53777A'\n        }\n        ;\n\n    var defaults = {\n\n        // the element to place meta data into\n        metaEl: null,\n        // default styles of drawn objects\n        styles: {\n\n            'point': colors.blue,\n\n            'circle' : {\n                strokeStyle: colors.blue,\n                lineWidth: 1,\n                fillStyle: colors.blue,\n                angleIndicator: colors.white\n            },\n\n            'rectangle' : {\n                strokeStyle: colors.violet,\n                lineWidth: 1,\n                fillStyle: colors.violet,\n                angleIndicator: colors.white\n            },\n\n            'convex-polygon' : {\n                strokeStyle: colors.violet,\n                lineWidth: 1,\n                fillStyle: colors.violet,\n                angleIndicator: colors.white\n            }\n        },\n        offset: { x: 0, y: 0 }\n    };\n\n    return {\n\n        // extended\n        init: function( options ){\n\n            var self = this;\n\n            // call proto init\n            proto.init.call(this, options);\n\n            // further options\n            this.options.defaults( defaults, true );\n            this.options.onChange(function(){\n                self.options.offset = new Physics.vector( self.options.offset );\n            });\n            this.options( options, true );\n\n            // hidden canvas\n            this.hiddenCanvas = document.createElement('canvas');\n            this.hiddenCanvas.width = this.hiddenCanvas.height = 100;\n\n            if (!this.hiddenCanvas.getContext){\n                throw \"Canvas not supported\";\n            }\n\n            this.hiddenCtx = this.hiddenCanvas.getContext('2d');\n\n            // actual viewport\n            var viewport = this.el;\n            if (viewport.nodeName.toUpperCase() !== 'CANVAS'){\n\n                viewport = document.createElement('canvas');\n                this.el.appendChild( viewport );\n                if (typeof this.options.el === 'string' && this.el === document.body){\n                    viewport.id = this.options.el;\n                }\n                this.el = viewport;\n            }\n\n            this.container = this.el.parentNode;\n            this.ctx = viewport.getContext('2d');\n\n            this.els = {};\n\n            if (this.options.meta){\n                var stats = this.options.metaEl || newEl();\n                stats.className = 'pjs-meta';\n                this.els.fps = newEl('span');\n                this.els.ipf = newEl('span');\n                stats.appendChild(newEl('span', 'fps: '));\n                stats.appendChild(this.els.fps);\n                stats.appendChild(newEl('br'));\n                stats.appendChild(newEl('span', 'ipf: '));\n                stats.appendChild(this.els.ipf);\n\n                viewport.parentNode.insertBefore(stats, viewport);\n            }\n\n            this._layers = {};\n            this.addLayer( 'main', this.el );\n\n            if ( this.options.autoResize ){\n                this.resize();\n            } else {\n                this.resize( this.options.width, this.options.height );\n            }\n        },\n\n        /**\n         * CanvasRenderer#layer( id ) -> Layer\n         * - id (String): The id for the layer\n         *\n         * Get the layer by id.\n         **/\n        layer: function( id ){\n\n            if ( id in this._layers ){\n                return this._layers[ id ];\n            }\n\n            return null;\n        },\n\n        /**\n         * CanvasRenderer#addLayer( id[, el, opts ] ) -> Layer\n         * - id (String): The id for the layer\n         * - el (HTMLElement): The canvas element to use for this layer\n         * - opts (Object): The options for this layer (see below)\n         *\n         * Create a new layer.\n         *\n         * Layers can have the following options:\n         *\n         * - width: The width\n         * - height: The height\n         * - manual: Draw manually (default: `false`)\n         * - autoResize: Automatically resize the layer when the renderer's [[CanvasRenderer#resize]] method is called. (default: `true`)\n         * - follow: A [[Body]]. Offset this layer's rendering to follow a body's position. (default: `null`)\n         * - offset: The offset [[Vectorish]] for this layer. (default: `null`)\n         * - scale: Scale the layer by this amount. (default: `1`)\n         * - zIndex: The zIndex for the layer's HTMLElement. (default: `1`)\n         **/\n        addLayer: function( id, el, opts ){\n\n            /** belongs to: CanvasRenderer\n             * class Layer\n             *\n             * A rendering layer for the canvas renderer.\n             *\n             * Create by calling [[CanvasRenderer#addLayer]].\n             **/\n\n            var self = this\n                ,bodies = []\n                ,styles = Physics.util.extend({}, this.options.styles)\n                ,layer = {\n                    /**\n                     * Layer#id = String\n                     *\n                     * The layer's ID\n                     **/\n                    id: id\n                    /**\n                     * Layer#el = HTMLElement\n                     *\n                     * The layer's Canvas\n                     **/\n                    ,el: el || document.createElement('canvas')\n                    /** related to: Physics.util.options\n                      * Layer#options( options ) -> Object\n                      * - options (Object): The options to set as an object\n                      * + (Object): The options\n                      *\n                      * Set options on this layer.\n                      *\n                      * Access options directly from the options object.\n                      *\n                      * Example:\n                      *\n                      * ```javascript\n                      * this.options.someOption;\n                      * ```\n                      **/\n                    ,options: Physics.util.options({\n                        width: this.el.width\n                        ,height: this.el.height\n                        ,manual: false\n                        ,autoResize: true\n                        ,follow: null\n                        ,offset: null\n                        ,scale: 1\n                        ,zIndex: 1\n                    })( opts )\n                }\n                ;\n\n            if ( id in this._layers ){\n                throw 'Layer \"' + id + '\" already added.';\n            }\n\n            this.el.parentNode.insertBefore( layer.el, this.el );\n            layer.el.style.position = 'absolute';\n            layer.el.style.zIndex = layer.options.zIndex;\n            layer.el.className += ' pjs-layer-' + layer.id;\n            layer.ctx = layer.el.getContext('2d');\n            layer.ctx.scale( 1, 1 );\n            layer.el.width = layer.options.width;\n            layer.el.height = layer.options.height;\n\n            /**\n             * Layer#bodies = Array\n             *\n             * The Bodies this layer is rendering.\n             *\n             * The \"main\" layer will render all world bodies if it's empty.\n             **/\n            layer.bodies = bodies;\n\n            /**\n             * Layer#reset( [arr] ) -> this\n             * - arr (Array): Array to replace the current stack of Bodies.\n             *\n             * Reset the stack.\n             **/\n            layer.reset = function( arr ){\n\n                bodies = arr || [];\n                return layer;\n            };\n\n            /**\n             * Layer#addToStack( arr ) -> this\n             * Layer#addToStack( body ) -> this\n             * - body (Body): Body to add\n             * - arr (Array): Array of bodies to add\n             *\n             * Add body (bodies) to the rendering stack for this layer.\n             *\n             * Bodies must be added to the stack in order to be rendered by this layer UNLESS it is the \"main\" layer.\n             **/\n            layer.addToStack = function( thing ){\n\n                if ( Physics.util.isArray( thing ) ){\n                    bodies.push.apply( bodies, thing );\n                } else {\n                    bodies.push( thing );\n                }\n                return layer;\n            };\n\n            /**\n             * Layer#removeFromStack( arr ) -> this\n             * Layer#removeFromStack( body ) -> this\n             * - body (Body): Body to remove\n             * - arr (Array): Array of bodies to remove\n             *\n             * Remove body (bodies) from the rendering stack for this layer.\n             **/\n            layer.removeFromStack = function( thing ){\n\n                var i, l;\n\n                if ( Physics.util.isArray( thing ) ){\n                    for ( i = 0, l = thing.length; i < l; ++i ){\n                        layer.removeFromStack(thing[ i ]);\n                    }\n                } else {\n                    i = Physics.util.indexOf( bodies, thing );\n                    if ( i > -1 ){\n                        bodies.splice( i, 1 );\n                    }\n                }\n                return layer;\n            };\n\n            /**\n             * Layer#render( [clear] ) -> this\n             * - clear (Boolean): Clear the canvas (default: `true`)\n             *\n             * Render the bodies in this layer's stack.\n             *\n             * If you want you can replace this function with your own to do custom rendering.\n             *\n             * Example:\n             *\n             * ```javascript\n             * layer.render = myCustomRenderFn;\n             * ```\n             **/\n            layer.render = function( clear ){\n\n                var body\n                    ,scratch = Physics.scratchpad()\n                    ,offset = scratch.vector().set(0, 0)\n                    ,scale = layer.options.scale\n                    ,view\n                    ,i\n                    ,l = bodies.length\n                    ,t = self._interpolateTime\n                    ,stack = (l || layer.id !== 'main') ? bodies : self._world._bodies\n                    ;\n\n                if ( layer.options.manual ){\n                    scratch.done();\n                    return layer;\n                }\n\n                if ( layer.options.offset ){\n                    if ( layer.options.offset === 'center' ){\n                        offset.add( layer.el.width * 0.5, layer.el.height * 0.5 ).mult( 1/scale );\n                    } else {\n                        offset.vadd( layer.options.offset ).mult( 1/scale );\n                    }\n                }\n\n                if ( layer.options.follow ){\n                    offset.vsub( layer.options.follow.state.pos );\n                    offset.sub( layer.options.follow.state.vel.get(0)*t, layer.options.follow.state.vel.get(1)*t );\n                }\n\n                if ( clear !== false ){\n                    layer.ctx.clearRect(0, 0, layer.el.width, layer.el.height);\n                }\n\n                if ( scale !== 1 ){\n                    layer.ctx.save();\n                    layer.ctx.scale( scale, scale );\n                }\n\n                for ( i = 0, l = stack.length; i < l; ++i ){\n\n                    body = stack[ i ];\n                    if ( !body.hidden ){\n                        view = body.view || ( body.view = self.createView(body.geometry, body.styles || styles[ body.geometry.name ]) );\n                        self.drawBody( body, body.view, layer.ctx, offset );\n                    }\n                }\n\n                if ( scale !== 1 ){\n                    layer.ctx.restore();\n                }\n\n                scratch.done();\n                return layer;\n            };\n\n            // remember layer\n            this._layers[ id ] = layer;\n\n            return layer;\n        },\n\n        /**\n         * CanvasRenderer#removeLayer( id ) -> this\n         * CanvasRenderer#removeLayer( layer ) -> this\n         * - id (String): The id for the layer\n         * - layer (Layer): The layer\n         *\n         * Remove a layer.\n         **/\n        removeLayer: function( idOrLayer ){\n\n            var id = idOrLayer.id ? idOrLayer.id : idOrLayer\n                ,el = this._layers[ id ].el\n                ;\n\n            if ( el !== this.el ){\n                el.parentNode.removeChild( el );\n            }\n            delete this._layers[ id ];\n            return this;\n        },\n\n        /**\n         * CanvasRenderer#resize( width, height ) -> this\n         * - width (Number): The width\n         * - height (Number): The height\n         *\n         * Resize all layer canvases that have the `autoResize` option set to `true`.\n         **/\n        resize: function( width, height ){\n\n            var layer;\n            proto.resize.call( this, width, height );\n\n            for ( var id in this._layers ){\n\n                layer = this._layers[ id ];\n                if ( layer.options.autoResize ){\n                    layer.el.width = this.width;\n                    layer.el.height = this.height;\n                }\n            }\n\n            return this;\n        },\n\n        /**\n         * CanvasRenderer#setStyle( styles[, ctx] )\n         * - styles (Object|String): Styles to set on the canvas context\n         * - ctx (Canvas2DContext): The canvas context\n         *\n         * Set styles on the specified canvas context (or main context).\n         **/\n        setStyle: function( styles, ctx ){\n\n            ctx = ctx || this.ctx;\n\n            if ( Physics.util.isObject(styles) ){\n\n                styles.strokeStyle = styles.lineWidth ? styles.strokeStyle : 'rgba(0,0,0,0)';\n                Physics.util.extend(ctx, styles);\n\n            } else {\n\n                ctx.fillStyle = ctx.strokeStyle = styles;\n                ctx.lineWidth = 1;\n            }\n        },\n\n        /**\n         * CanvasRenderer#drawCircle( x, y, r, styles[, ctx] )\n         * - x (Number): The x coord\n         * - y (Number): The y coord\n         * - r (Number): The circle radius\n         * - styles (Object): The styles configuration\n         * - ctx (Canvas2DContext): The canvas context\n         *\n         * Draw a circle to specified canvas context.\n         **/\n        drawCircle: function(x, y, r, styles, ctx){\n\n            ctx = ctx || this.ctx;\n\n            ctx.beginPath();\n            this.setStyle( styles, ctx );\n            ctx.arc(x, y, r, 0, Pi2, false);\n            ctx.closePath();\n            ctx.stroke();\n            ctx.fill();\n        },\n\n        /**\n         * CanvasRenderer#drawPolygon( verts, styles[, ctx] )\n         * - verts (Array): Array of [[Vectorish]] vertices\n         * - styles (Object): The styles configuration\n         * - ctx (Canvas2DContext): The canvas context\n         *\n         * Draw a polygon to specified canvas context.\n         **/\n        drawPolygon: function(verts, styles, ctx){\n\n            var vert = verts[0]\n                ,x = vert.x\n                ,y = vert.y\n                ,l = verts.length\n                ;\n\n            ctx = ctx || this.ctx;\n            ctx.beginPath();\n            this.setStyle( styles, ctx );\n\n            ctx.moveTo(x, y);\n\n            for ( var i = 1; i < l; ++i ){\n\n                vert = verts[ i ];\n                x = vert.x;\n                y = vert.y;\n                ctx.lineTo(x, y);\n            }\n\n            if ( l > 2 ){\n                ctx.closePath();\n            }\n\n            ctx.stroke();\n            ctx.fill();\n        },\n\n        /**\n         * CanvasRenderer#drawRect( x, y, width, height, styles[, ctx] )\n         * - x (Number): The x coord\n         * - y (Number): The y coord\n         * - width (Number): The width\n         * - height (Number): The height\n         * - styles (Object): The styles configuration\n         * - ctx (Canvas2DContext): The canvas context\n         *\n         * Draw a rectangle to specified canvas context.\n         **/\n        drawRect: function(x, y, width, height, styles, ctx){\n\n            var hw = width * 0.5\n                ,hh = height * 0.5\n                ;\n\n            ctx = ctx || this.ctx;\n            this.setStyle( styles, ctx );\n            ctx.beginPath();\n            ctx.rect(x - hw, y - hh, width, height);\n            ctx.closePath();\n            ctx.stroke();\n            ctx.fill();\n        },\n\n        /**\n         * CanvasRenderer#drawLine( from, to, styles[, ctx] )\n         * - from (Vectorish): The starting pt\n         * - to (Vectorish): The ending pt\n         * - styles (Object): The styles configuration\n         * - ctx (Canvas2DContext): The canvas context\n         *\n         * Draw a line onto specified canvas context.\n         **/\n        drawLine: function(from, to, styles, ctx){\n\n            var x = from.x\n                ,y = from.y\n                ;\n\n            ctx = ctx || this.ctx;\n\n            ctx.beginPath();\n            this.setStyle( styles, ctx );\n\n            ctx.moveTo(x, y);\n\n            x = to.x;\n            y = to.y;\n\n            ctx.lineTo(x, y);\n\n            ctx.stroke();\n            ctx.fill();\n        },\n\n        /**\n         * CanvasRenderer#draw( geometry[, styles, ctx, offset] ) -> this\n         * - geometry (Geometry): The shape to draw\n         * - styles (Object): The styles configuration\n         * - ctx (Canvas2DContext): The canvas context\n         * - offset (Vectorish): The offset from center\n         *\n         * Draw a geometry to a context.\n         **/\n        draw: function( geometry, styles, ctx, offset ){\n\n            var name = geometry.name\n                ,x = +(offset && offset.x)\n                ,y = +(offset && offset.y)\n                ,w = geometry.aabb().hw\n                ;\n\n            ctx = ctx || this.ctx;\n            styles = styles || this.options.styles[ name ] || this.options.styles.circle || {};\n\n            ctx.save();\n            ctx.translate(x, y);\n\n            if (name === 'circle'){\n\n                this.drawCircle(0, 0, geometry.radius, styles, ctx);\n\n            } else if (name === 'convex-polygon'){\n\n                this.drawPolygon(geometry.vertices, styles, ctx);\n\n            } else if (name === 'rectangle'){\n\n                this.drawRect(0, 0, geometry.width, geometry.height, styles, ctx);\n\n            } else if (name === 'compound'){\n\n                for ( var i = 0, l = geometry.children.length, ch; i < l; i++ ){\n                    ch = geometry.children[ i ];\n\n                    // translate\n                    ctx.translate(ch.pos.x, ch.pos.y);\n                    // rotate\n                    ctx.rotate(ch.angle);\n\n                    this.draw( ch.g, styles, ctx );\n\n                    // unrotate\n                    ctx.rotate(-ch.angle);\n                    // untranslate\n                    ctx.translate(-ch.pos.x, -ch.pos.y);\n                }\n\n            } else {\n\n                // assume it's a point\n                this.drawCircle(0, 0, 1, styles, ctx);\n            }\n\n            if (name !== 'compound' && styles.angleIndicator){\n\n                ctx.beginPath();\n                this.setStyle( styles.angleIndicator, ctx );\n                ctx.moveTo(0, 0);\n                ctx.lineTo(w, 0);\n                ctx.closePath();\n                ctx.stroke();\n            }\n\n            ctx.restore();\n\n            return this;\n        },\n\n        // extended\n        createView: function( geometry, styles ){\n\n            var view\n                ,aabb = geometry.aabb()\n                ,hw = aabb.hw + Math.abs(aabb.x)\n                ,hh = aabb.hh + Math.abs(aabb.y)\n                ,offset = { x: hw + 1, y: hh + 1 }\n                ,hiddenCtx = this.hiddenCtx\n                ,hiddenCanvas = this.hiddenCanvas\n                ;\n\n            styles = styles || this.options.styles[ name ] || this.options.styles.circle || {};\n\n            // must want an image\n            if ( styles.src ){\n                view = new Image();\n                view.src = styles.src;\n                if ( styles.width ){\n                    view.width = styles.width;\n                }\n                if ( styles.height ){\n                    view.height = styles.height;\n                }\n                return view;\n            }\n\n            offset.x += styles.lineWidth | 0;\n            offset.y += styles.lineWidth | 0;\n\n            // clear and resize\n            hiddenCanvas.width = 2 * hw + 2 + (2 * styles.lineWidth|0);\n            hiddenCanvas.height = 2 * hh + 2 + (2 * styles.lineWidth|0);\n\n            this.draw( geometry, styles, hiddenCtx, offset );\n\n            view = new Image( hiddenCanvas.width, hiddenCanvas.height );\n            view.src = hiddenCanvas.toDataURL('image/png');\n            return view;\n        },\n\n        // extended\n        drawMeta: function( meta ){\n\n            this.els.fps.innerHTML = meta.fps.toFixed(2);\n            this.els.ipf.innerHTML = meta.ipf;\n        },\n\n        // extended\n        drawBody: function( body, view, ctx, offset ){\n\n            var pos = body.state.pos\n                ,os = body.offset\n                ,v = body.state.vel\n                ,t = this._interpolateTime || 0\n                ,x\n                ,y\n                ,ang\n                ,aabb\n                ;\n\n            offset = offset || this.options.offset;\n            ctx = ctx || this.ctx;\n\n            // interpolate positions\n            x = pos._[0] + offset.x + v._[0] * t;\n            y = pos._[1] + offset.y + v._[1] * t;\n            ang = body.state.angular.pos + body.state.angular.vel * t;\n\n            ctx.save();\n            ctx.translate( x, y );\n            ctx.rotate( ang );\n            ctx.translate( os._[0], os._[1] );\n            ctx.drawImage(view, -view.width/2, -view.height/2, view.width, view.height);\n            ctx.restore();\n        },\n\n        // extended\n        render: function( bodies, meta ){\n\n            var body\n                ,view\n                ,pos\n                ;\n\n            this._world.emit('beforeRender', {\n                renderer: this,\n                meta: meta\n            });\n\n            if ( this.options.meta ) {\n                this.drawMeta( meta );\n            }\n\n            this._interpolateTime = meta.interpolateTime;\n\n            for ( var id in this._layers ){\n\n                this._layers[ id ].render();\n            }\n\n            return this;\n        }\n    };\n});\n\n\n// ---\n// inside: src/renderers/dom.js\n\n/**\n * class DomRenderer < Renderer\n *\n * Physics.renderer('dom')\n *\n * Renderer that manipulates DOM elements according to the physics simulation. Very primative...\n **/\nPhysics.renderer('dom', function( proto ){\n\n    if ( !document ){\n        // must be in node environment\n        return {};\n    }\n\n    // utility methods\n    var thePrefix = {}\n        ,tmpdiv = document.createElement(\"div\")\n        ,toTitleCase = function toTitleCase(str) {\n            return str.replace(/(?:^|\\s)\\w/g, function(match) {\n                return match.toUpperCase();\n            });\n        }\n        // return the prefixed name for the specified css property\n        ,pfx = function pfx(prop) {\n\n            if (thePrefix[prop]){\n                return thePrefix[prop];\n            }\n\n            var arrayOfPrefixes = ['Webkit', 'Moz', 'Ms', 'O']\n                ,name\n                ;\n\n            for (var i = 0, l = arrayOfPrefixes.length; i < l; ++i) {\n\n                name = arrayOfPrefixes[i] + toTitleCase(prop);\n\n                if (name in tmpdiv.style){\n                    return thePrefix[prop] = name;\n                }\n            }\n\n            if (name in tmpdiv.style){\n                return thePrefix[prop] = prop;\n            }\n\n            return false;\n        }\n        ;\n\n    var classpfx = 'pjs-'\n        ,px = 'px'\n        ,cssTransform = pfx('transform')\n        ,borderRadius = pfx('borderRadius')\n        ;\n\n    var newEl = function( node, content ){\n            var el = document.createElement(node || 'div');\n            if (content){\n                el.innerHTML = content;\n            }\n            return el;\n        }\n        ,drawBody\n        ;\n\n    return {\n\n        // extended\n        init: function( options ){\n\n            // call proto init\n            proto.init.call(this, options);\n\n            var viewport = this.el;\n            viewport.style.position = 'relative';\n            viewport.style.overflow = 'hidden';\n            viewport.style[cssTransform] = 'translateZ(0)'; // force GPU accel\n            viewport.style.width = this.options.width + px;\n            viewport.style.height = this.options.height + px;\n\n            this.els = {};\n\n            if (options.meta){\n                var stats = newEl();\n                stats.className = 'pjs-meta';\n                this.els.fps = newEl('span');\n                this.els.ipf = newEl('span');\n                stats.appendChild(newEl('span', 'fps: '));\n                stats.appendChild(this.els.fps);\n                stats.appendChild(newEl('br'));\n                stats.appendChild(newEl('span', 'ipf: '));\n                stats.appendChild(this.els.ipf);\n\n                viewport.appendChild(stats);\n            }\n\n            if ( this.options.autoResize ){\n                this.resize();\n            } else {\n                this.resize( this.options.width, this.options.height );\n            }\n        },\n\n        // extended\n        resize: function( width, height ){\n\n            proto.resize.call( this, width, height );\n            this.el.style.width = this.width + px;\n            this.el.style.height = this.height + px;\n        },\n\n        /** internal\n         * DomRenderer#pointProperties( el, geometry )\n         * - el (HTMLElement): The element\n         * - geometry (Geometry): The body's geometry\n         *\n         * Set dom element style properties for a point.\n         **/\n        pointProperties: function( el, geometry ){\n\n            el.style.width = '2px';\n            el.style.height = '2px';\n            el.style.marginLeft = '-1px';\n            el.style.marginTop = '-1px';\n            el.style[ borderRadius ] = '50%';\n        },\n\n        /** internal\n         * DomRenderer#circleProperties( el, geometry )\n         * - el (HTMLElement): The element\n         * - geometry (Geometry): The body's geometry\n         *\n         * Set dom element style properties for a circle.\n         **/\n        circleProperties: function( el, geometry ){\n\n            var aabb = geometry.aabb();\n\n            el.style.width = (aabb.hw * 2) + px;\n            el.style.height = (aabb.hh * 2) + px;\n            el.style.marginLeft = (-aabb.hw) + px;\n            el.style.marginTop = (-aabb.hh) + px;\n            el.style[ borderRadius ] = '50%';\n        },\n\n        /** internal\n         * DomRenderer#rectangleProperties( el, geometry )\n         * - el (HTMLElement): The element\n         * - geometry (Geometry): The body's geometry\n         *\n         * Set dom element style properties for a rectangle.\n         **/\n        rectangleProperties: function( el, geometry ){\n\n            var aabb = geometry.aabb();\n\n            el.style.width = (aabb.hw * 2) + px;\n            el.style.height = (aabb.hh * 2) + px;\n            el.style.marginLeft = (-aabb.hw) + px;\n            el.style.marginTop = (-aabb.hh) + px;\n        },\n\n        // extended\n        createView: function( geometry ){\n\n            var el = newEl()\n                ,chel\n                ,fn = geometry.name + 'Properties'\n                ;\n\n            el.className = classpfx + geometry.name;\n            el.style.position = 'absolute';\n            el.style.top = '0px';\n            el.style.left = '0px';\n\n            if ( geometry.name === 'compound' ){\n\n                for ( var i = 0, l = geometry.children.length, ch; i < l; i++ ){\n                    ch = geometry.children[ i ];\n                    chel = newEl();\n                    chel.className = classpfx + geometry.name + ' ' + classpfx + 'child';\n                    chel.style.position = 'absolute';\n                    chel.style.top = '0px';\n                    chel.style.left = '0px';\n                    if ( this[ ch.g.name + 'Properties' ] ){\n                        this[ ch.g.name + 'Properties' ](chel, ch.g);\n                    }\n                    chel.style[cssTransform] = 'translate('+ch.pos._[0]+'px,'+ch.pos._[1]+'px) rotate('+ ch.angle +'rad)';\n                    el.appendChild( chel );\n                }\n\n            } else if ( this[ fn ] ){\n                this[ fn ](el, geometry);\n            }\n\n            this.el.appendChild( el );\n            return el;\n        },\n\n        // extended\n        connect: function( world ){\n\n            world.on( 'add:body', this.attach, this );\n            world.on( 'remove:body', this.detach, this );\n        },\n\n        // extended\n        disconnect: function( world ){\n\n            world.off( 'add:body', this.attach, this );\n            world.off( 'remove:body', this.detach, this );\n        },\n\n        /**\n         * DomRenderer#detach( data ) -> this\n         * - data (HTMLElement|Object): DOM node or event data (`data.body`)\n         *\n         * Event callback to detach a node from the DOM\n         **/\n        detach: function( data ){\n\n            // interpred data as either dom node or event data\n            var el = (data.nodeType && data) || (data.body && data.body.view)\n                ,par = el && el.parentNode\n                ;\n\n            if ( el && par ){\n                // remove view from dom\n                par.removeChild( el );\n            }\n\n            return this;\n        },\n\n        /**\n         * DomRenderer#attach( data ) -> this\n         * - data (HTMLElement|Object): DOM node or event data (`data.body`)\n         *\n         * Event callback to attach a node to the viewport\n         **/\n        attach: function( data ){\n\n            // interpred data as either dom node or event data\n            var el = (data.nodeType && data) || (data.body && data.body.view)\n                ;\n\n            if ( el ){\n                // attach to viewport\n                this.el.appendChild( el );\n            }\n\n            return this;\n        },\n\n        // extended\n        drawMeta: function( meta ){\n\n            this.els.fps.innerHTML = meta.fps.toFixed(2);\n            this.els.ipf.innerHTML = meta.ipf;\n        },\n\n        // extended\n        drawBody: function( body, view ){\n\n            var pos = body.state.pos\n                ,v = body.state.vel\n                ,os = body.offset\n                ,x\n                ,y\n                ,ang\n                ,t = this._interpolateTime\n                ;\n\n            // interpolate positions\n            x = pos._[0] + v._[0] * t;\n            y = pos._[1] + v._[1] * t;\n            ang = body.state.angular.pos + body.state.angular.vel * t;\n            view.style[cssTransform] = 'translate('+x+'px,'+y+'px) rotate('+ ang +'rad) translate('+os._[0]+'px,'+os._[1]+'px)';\n        }\n    };\n});\n\n\n// ---\n// inside: src/renderers/pixi-renderer.js\n\n/*\n * @requires pixi.js\n */\n/**\n * class PixiRenderer < Renderer\n *\n * Physics.renderer('pixi')\n *\n * Renderer that uses the PIXI.js library. [Documentation can be found here](https://github.com/wellcaffeinated/PhysicsJS/wiki/PIXI-Renderer).\n *\n * Additional config options:\n *\n * - metaEl: HTMLElement to write meta information like FPS and IPF into. (default: autogenerated)\n * - offset: Offset the shapes by this amount. (default: `{ x: 0, y: 0 }`)\n * - styles: Styles to use to draw the shapes. (see below)\n *\n * The styles property should contain _default_ styles for each shape you want to draw.\n *\n * Example:\n *\n * ```javascript\n * styles: {\n *    // Defines the default canvas colour\n *    'color': '0x66FF99',\n *\n *    'circle' : {\n *        strokeStyle: '0xE8900C',\n *        lineWidth: 3,\n *        fillStyle: '0xD5DE4C',\n *        angleIndicator: '0xE8900C',\n *        strokeAlpha: 1,\n *        fillAlpha: 1\n *    },\n *\n *    'convex-polygon' : {\n *        strokeStyle: '0xE8900C',\n *        lineWidth: 3,\n *        fillStyle: '0xD5DE4C',\n *        angleIndicator: '0xE8900C'\n *    }\n * }\n * ```\n *\n * Styles can also be defined on a per-body basis. Use the \"styles\" property for a body:\n *\n * Example:\n *\n * ```javascript\n * Physics.body('circle', {\n *     // ...\n *     styles: {\n *        strokeStyle: '0x542437',\n *        lineWidth: 1,\n *        fillStyle: '0x542437',\n *        angleIndicator: '0xFFFFFF'\n *    }\n * });\n * ```\n *\n * You can also define an image to use for a body:\n *\n * Example:\n *\n * ```javascript\n * Physics.body('circle', {\n *     // ...\n *     styles: {\n *        src: 'path/to/image.jpg',\n *        width: 40,\n *        height: 50,\n *        anchor: { x: 0.5, y: 0.5 }\n *    }\n * });\n * ```\n **/\n/* global PIXI */\nPhysics.renderer('pixi', function( parent ){\n\n    if ( !document ){\n        // must be in node environment\n        return {};\n    }\n\n    var Pi2 = Math.PI * 2\n        ,colors = {\n            white: '0xFFFFFF'\n            ,violet: '0x542437'\n            ,blue: '0x53777A'\n        }\n        ,fontStyles = {\n            font: \"18px monospace\",\n            fill: \"black\",\n            align: \"left\"\n        }\n\n        ,defaults = {\n\n            // the element to place meta data into\n            metaEl: null,\n            offset: { x: 0, y: 0 },\n            // Provide some default colours\n            styles: {\n                // Defines the default canvas colour\n                'color': false,\n\n                'point': colors.blue,\n\n                'circle' : {\n                    strokeStyle: colors.blue,\n                    lineWidth: 1,\n                    fillStyle: colors.blue,\n                    angleIndicator: colors.white,\n                    fillAlpha: 1,\n                    strokeAlpha: 1,\n                    alpha: 1\n                },\n\n                'rectangle' : {\n                    strokeStyle: colors.violet,\n                    lineWidth: 1,\n                    fillStyle: colors.violet,\n                    angleIndicator: colors.white,\n                    fillAlpha: 1,\n                    strokeAlpha: 1,\n                    alpha: 1\n                },\n\n                'convex-polygon' : {\n                    strokeStyle: colors.violet,\n                    lineWidth: 1,\n                    fillStyle: colors.violet,\n                    angleIndicator: colors.white,\n                    fillAlpha: 1,\n                    strokeAlpha: 1,\n                    alpha: 1\n                }\n            }\n        }\n        ;\n\n    return {\n\n        // extended\n        init: function( options ){\n\n            var self = this\n                ,el\n                ,isTransparent\n                ;\n\n            if (typeof PIXI === 'undefined') {\n                throw \"PIXI not present - cannot continue\";\n            }\n\n            // call parent init\n            parent.init.call(this, options);\n\n            // further options\n            this.options.defaults( defaults, true );\n            this.options.onChange(function(){\n                self.options.offset = new Physics.vector( self.options.offset );\n            });\n            this.options( options, true );\n\n            isTransparent = (!this.options.styles.color || this.options.styles.color === 'transparent');\n            // Hook in PIXI stage here\n            this.stage = new PIXI.Stage(this.options.styles.color);\n\n            // Create empty meta object for use later\n            this.meta = {};\n\n            el = (this.el && this.el.nodeName === 'CANVAS') ? el : null;\n            // add the renderer view element to the DOM according to its type\n            this.renderer = new PIXI.autoDetectRenderer(this.options.width, this.options.height, {\n                view: el,\n                transparent: isTransparent,\n                resolution: window.devicePixelRatio || 1\n            });\n\n            if ( !el ){\n                this.el = this.el || document.body;\n                // add to passed in element\n                this.el.appendChild( this.renderer.view );\n            }\n\n            if ( this.options.autoResize ){\n                this.resize();\n            } else {\n                this.resize( this.options.width, this.options.height );\n            }\n        },\n\n        // extended\n        resize: function( width, height ){\n\n            parent.resize.call( this, width, height );\n            this.renderer.resize( this.width, this.height );\n        },\n\n        // extended\n        connect: function( world ){\n\n            world.on( 'add:body', this.attach, this );\n            world.on( 'remove:body', this.detach, this );\n        },\n\n        // extended\n        disconnect: function( world ){\n\n            world.off( 'add:body', this.attach, this );\n            world.off( 'remove:body', this.detach, this );\n        },\n\n        /**\n         * PixiRenderer#detach( data ) -> this\n         * - data (PIXI.Graphics|Object): Graphics object or event data (`data.body`)\n         *\n         * Event callback to detach a child from the stage\n         **/\n        detach: function( data ){\n\n            // interpred data as either dom node or event data\n            var el = (data instanceof PIXI.Graphics && data) || (data.body && data.body.view);\n\n            if ( el ){\n                // remove view from dom\n                this.stage.removeChild( el );\n            }\n\n            return this;\n        },\n\n        /**\n         * PixiRenderer#attach( data ) -> this\n         * - data (PIXI.Graphics|Object): Graphics object or event data (`data.body`)\n         *\n         * Event callback to attach a child to the stage\n         **/\n        attach: function( data ){\n\n            // interpred data as either dom node or event data\n            var el = (data instanceof PIXI.Graphics && data) || (data.body && data.body.view);\n\n            if ( el ){\n                // attach to viewport\n                this.stage.addChild( el );\n            }\n\n            return this;\n        },\n\n        /**\n         * PixiRenderer#loadSpriteSheets( assetsToLoad, callback ) -> this\n         * - assetsToLoad (Array): Array of spritesheets to load\n         * - callback (Function): Function to call when loading is complete\n         *\n         * Loads textures defined in a spritesheet\n         **/\n        loadSpriteSheets: function( assetsToLoad, callback ){\n\n            if ( !Physics.util.isArray( assetsToLoad ) ) {\n                throw 'Spritesheets must be defined in arrays';\n            }\n\n            var self = this\n                ,loader = new PIXI.AssetLoader(assetsToLoad)\n                ;\n\n            // Start loading resources!\n            loader.load();\n\n            loader.on('onComplete', function(evt){\n                self.assetsLoaded = true;\n                callback();\n            });\n\n            return self;\n        },\n\n        /**\n         * PixiRenderer#drawBody( body, view )\n         * - body (Body): The body to draw\n         * - view (DisplayObject): The pixi display object\n         *\n         * Draw a PIXI.DisplayObject to the stage.\n         **/\n        drawBody: function( body, view ){\n            var pos = body.state.pos\n                ,v = body.state.vel\n                ,os = body.offset\n                ,t = this._interpolateTime || 0\n                ,x\n                ,y\n                ,ang\n                ;\n\n            // interpolate positions\n            x = pos._[0] + v._[0] * t;\n            y = pos._[1] + v._[1] * t;\n            ang = body.state.angular.pos + body.state.angular.vel * t;\n\n            view.position.set( x, y );\n            view.pivot.set( -os._[0], -os._[1] );\n            view.rotation = ang;\n        },\n\n        // extended\n        render: function( bodies, meta ){\n\n            parent.render.call(this, bodies, meta);\n            this.renderer.render(this.stage);\n        },\n\n        /**\n         * PixiRenderer#setStyles( graphics, styles ) -> PIXI.Graphics\n         * - graphics (PIXI.Graphics): The graphics object to set styles on\n         * - styles (Object): The styles configuration\n         * + (PIXI.Graphics): A graphic object\n         *\n         * Set styles on pixi graphics object\n         **/\n        setStyles: function( graphics, styles ){\n\n            if ( Physics.util.isObject(styles) ){\n\n                if ( styles.fillStyle && styles.fillStyle !== 'transparent' ){\n                    graphics.beginFill( styles.fillStyle );\n                    graphics.fillAlpha = styles.fillAlpha !== undefined ? styles.fillAlpha : 1;\n                } else {\n                    graphics.beginFill();\n                    graphics.fillAlpha = 0;\n                }\n\n                graphics.lineStyle( styles.lineWidth || 0, styles.strokeStyle, styles.strokeAlpha !== undefined ? styles.strokeAlpha : 1 );\n                graphics.alpha = styles.alpha !== undefined ? styles.alpha : 1;\n\n            } else {\n\n                if ( styles && styles !== 'transparent' ){\n                    graphics.beginFill( styles );\n                } else {\n                    graphics.beginFill();\n                    graphics.fillAlpha = 0;\n                }\n\n                graphics.lineStyle( 0 );\n            }\n\n            return graphics;\n        },\n\n        /**\n         * PixiRenderer#createCircle( x, y, r, styles ) -> PIXI.Graphics\n         * - x (Number): The x coord\n         * - y (Number): The y coord\n         * - r (Number): The circle radius\n         * - styles (Object): The styles configuration\n         * + (PIXI.Graphics): A graphic object representing a circle.\n         *\n         * Create a circle for use in PIXI stage\n         **/\n        createCircle: function( x, y, r, styles ){\n\n            var graphics = new PIXI.Graphics();\n            this.setStyles( graphics, styles );\n            graphics.drawCircle( x, y, r );\n            graphics.endFill();\n            return graphics;\n        },\n\n        /**\n         * PixiRenderer#createRect( x, y, r, styles ) -> PIXI.Graphics\n         * - x (Number): The x coord\n         * - y (Number): The y coord\n         * - width (Number): The rectangle width\n         * - height (Number): The rectangle height\n         * - styles (Object): The styles configuration\n         * + (PIXI.Graphics): A graphic object representing a circle.\n         *\n         * Create a rectangle for use in PIXI stage\n         **/\n        createRect: function( x, y, width, height, styles ){\n\n            var graphics = new PIXI.Graphics();\n            this.setStyles( graphics, styles );\n            graphics.drawRect( x, y, width, height );\n            graphics.endFill();\n            return graphics;\n        },\n\n        /**\n         * PixiRenderer#createPolygon( verts, styles ) -> PIXI.Graphics\n         * - verts (Array): Array of [[Vectorish]] vertices\n         * - styles (Object): The styles configuration\n         * + (PIXI.Graphics): A graphic object representing a polygon.\n         *\n         * Create a polygon for use in PIXI stage\n         **/\n        createPolygon: function( verts, styles ){\n\n            var vert = verts[0]\n                ,x = vert.x\n                ,y = vert.y\n                ,l = verts.length\n                ,start = {\n                    x: x\n                    ,y: y\n                }\n                ,graphics = new PIXI.Graphics()\n                ;\n\n            this.setStyles( graphics, styles );\n\n            graphics.moveTo(x, y);\n\n            for ( var i = 1; i < l; ++i ){\n\n                vert = verts[ i ];\n                x = vert.x;\n                y = vert.y;\n                graphics.lineTo(x, y);\n            }\n\n            if (l > 2){\n                graphics.lineTo(start.x, start.y);\n            }\n\n            graphics.endFill();\n            return graphics;\n        },\n\n        /**\n         * PixiRenderer#createLine( from, to, styles ) -> PIXI.Graphics\n         * - from (Vectorish): Starting point\n         * - to (Vectorish): Ending point\n         * - styles (Object): The styles configuration\n         * + (PIXI.Graphics): A graphic object representing a polygon.\n         *\n         * Create a line for use in PIXI stage\n         **/\n        createLine: function( from, to, styles ){\n\n            var x = from.x\n                ,y = from.y\n                ;\n\n            var graphics = new PIXI.Graphics();\n            this.setStyles( graphics, styles );\n\n            graphics.moveTo(x, y);\n\n            x = to.x;\n            y = to.y;\n\n            graphics.lineTo(x, y);\n\n            graphics.endFill();\n            return graphics;\n        },\n\n        // extended\n        createView: function( geometry, styles, parent ){\n\n            var view = null\n                ,aabb = geometry.aabb()\n                ,hw = aabb.hw + Math.abs(aabb.x)\n                ,hh = aabb.hh + Math.abs(aabb.y)\n                ,name = geometry.name\n                ;\n\n            parent = parent || this.stage;\n            styles = styles || this.options.styles[ name ] || this.options.styles.circle || {};\n\n            // must want an image\n            if ( styles.src ){\n                view = PIXI.Sprite.fromImage( styles.src );\n                view.anchor.set( 0.5, 0.5 );\n                if ( styles.anchor ) {\n                    view.anchor.x = styles.anchor.x;\n                    view.anchor.y = styles.anchor.y;\n                }\n                if ( styles.width ){\n                    view.width = styles.width;\n                }\n                if ( styles.height ){\n                    view.height = styles.height;\n                }\n                parent.addChild(view);\n                return view;\n            }\n\n            if (name === 'circle'){\n\n                view = this.createCircle(0, 0, geometry.radius, styles);\n\n            } else if (name === 'convex-polygon'){\n\n                view = this.createPolygon(geometry.vertices, styles);\n\n            } else if (name === 'rectangle'){\n\n                view = this.createRect(-geometry.width/2, -geometry.height/2, geometry.width, geometry.height, styles);\n            } else if (name === 'compound'){\n\n                view = new PIXI.Graphics();\n\n                for ( var i = 0, l = geometry.children.length, ch, chview; i < l; i++ ){\n                    ch = geometry.children[ i ];\n                    chview = this.createView( ch.g, styles, view );\n                    chview.position.set( ch.pos.x, ch.pos.y );\n                    chview.rotation = ch.angle;\n                }\n            } else {\n\n                // assume it's a point\n                view = this.createCircle(0, 0, 1, styles);\n            }\n\n            if ( name !== 'compound' && styles.angleIndicator && styles.angleIndicator !== 'transparent' ){\n\n                view.lineStyle( styles.lineWidth, styles.angleIndicator );\n                view.moveTo( 0, 0 );\n                view.lineTo( hw, 0 );\n            }\n\n            if ( name !== 'compound' ){\n                view.cacheAsBitmap = true;\n            }\n\n            parent.addChild(view);\n            return view;\n        },\n\n        // extended\n        drawMeta: function( meta ){\n            if (!this.meta.loaded){\n                // define the font styles here\n                this.meta.fps = new PIXI.Text('FPS: ' + meta.fps.toFixed(2), fontStyles);\n                this.meta.fps.position.x = 15;\n                this.meta.fps.position.y = 5;\n\n                this.meta.ipf = new PIXI.Text('IPF: ' + meta.ipf, fontStyles);\n                this.meta.ipf.position.x = 15;\n                this.meta.ipf.position.y = 30;\n\n                this.stage.addChild(this.meta.fps);\n                this.stage.addChild(this.meta.ipf);\n                this.meta.loaded = true;\n            } else {\n                this.meta.fps.setText('FPS: ' + meta.fps.toFixed(2));\n                this.meta.ipf.setText('IPF: ' + meta.ipf);\n            }\n        },\n\n        /**\n         * PixiRenderer#createDisplay( type, options ) -> PIXI.DisplayObject\n         * - type (String): The type of PIXI.DisplayObject to make\n         * - options (Object): Options to apply to the view.\n         * + (PIXI.DisplayObject): An object that is renderable.\n         *\n         * Create a PIXI sprite or movie clip.\n         **/\n        createDisplay: function( type, options ){\n            var view = null\n                ,texture = null\n                ;\n            switch (type){\n                // Create a sprite object\n                case 'sprite':\n                    texture = PIXI.Texture.fromImage(options.texture);\n                    view = new PIXI.Sprite(texture);\n                    if (options.anchor ) {\n                        view.anchor.x = options.anchor.x;\n                        view.anchor.y = options.anchor.y;\n                    }\n                    // If a container is specified, use add to that container\n                    if (options.container) {\n                        options.container.addChild(view);\n                    } else {\n                        // Otherwise just add the view to the stage\n                        this.stage.addChild(view);\n                    }\n                    return view;\n                // Create a movieclip object\n                case 'movieclip':\n                    if (!this.assetsLoaded) {\n                        throw \"No assets have been loaded. Use loadSpritesheet() first\";\n                    }\n                    var tex = []\n                        ,i = 0\n                        ;\n                    // Populate our movieclip\n                    for (i; i < options.frames.length; i++) {\n                        texture = PIXI.Texture.fromFrame(options.frames[i]);\n                        tex.push(texture);\n                    }\n                    view = new PIXI.MovieClip(tex);\n                    if (options.anchor ) {\n                        view.anchor.x = options.anchor.x;\n                        view.anchor.y = options.anchor.y;\n                    }\n                    // If a container is specified, use add to that container\n                    if (options.container) {\n                        options.container.addChild(view);\n                    } else {\n                        // Otherwise just add the view to the stage\n                        this.stage.addChild(view);\n                    }\n                    return view;\n                // Create a default case\n                default:\n                    throw 'Invalid PIXI.DisplayObject passed';\n            }\n        },\n\n        /**\n         * PixiRenderer#centerAnchor( view )\n         * - view (PIXI.DisplayObject): The view to center\n         *\n         * Centers the anchor to {x: 0.5, y: 0.5} of a view\n         **/\n        centerAnchor: function( view ) {\n            if (view !== null){\n                view.anchor.x = 0.5;\n                view.anchor.y = 0.5;\n            }\n        }\n    };\n});\n\n\n// ---\n// inside: src/outro.js\n\nreturn Physics;\n}));"],"sourceRoot":""}