{"version":3,"sources":["webpack:///v1-bundle-b13343bf5e67236e0fb7.js","webpack:///webpack/bootstrap 9b8f6a2e7ac748840ade","webpack:///./node_modules/preact/dist/preact.esm.js","webpack:///(webpack)/buildin/global.js","webpack:///./src/lib/bem.js","webpack:///./src/lib/provider.js","webpack:///./src/v1/components/App.css","webpack:///./src/v1/client.polyfill.js","webpack:///./node_modules/promise-polyfill/src/polyfill.js","webpack:///./node_modules/promise-polyfill/src/index.js","webpack:///./node_modules/timers-browserify/main.js","webpack:///./node_modules/setimmediate/setImmediate.js","webpack:///./node_modules/process/browser.js","webpack:///./node_modules/intersection-observer/intersection-observer.js","webpack:///./src/v1/client.js","webpack:///./node_modules/domready/ready.js","webpack:///./src/lib/nodelistToArray.js","webpack:///./src/lib/uuid.js","webpack:///./src/lib/errorReporting.js","webpack:///./node_modules/@nrk/dh-simple-error-report/dist/simple-error-report.min.js","webpack:///./src/v1/components/App.js","webpack:///./src/lib/debounce.js","webpack:///./src/v1/components/InfoBox.js","webpack:///./src/v1/components/Counter.js","webpack:///./src/v1/components/Counter.css","webpack:///./src/v1/components/InfoBox.css","webpack:///./src/v1/components/Trash.js","webpack:///./src/v1/modules/trashController.js","webpack:///./node_modules/matter-js/build/matter.js","webpack:///./src/v1/components/Trash.css","webpack:///./src/v1/components/Sea.js","webpack:///./src/v1/components/Sea.css","webpack:///./src/v1/components/SeaOverlay.js","webpack:///./src/v1/components/SeaOverlay.css","webpack:///./src/v1/components/SeaLight.js","webpack:///./src/v1/components/SeaLight.css","webpack:///./node_modules/@nrk/dh-analytics-utils/dist/dh-analytics-utils.min.js","webpack:///./src/lib/getContextId.js"],"names":["modules","__webpack_require__","moduleId","installedModules","exports","module","i","l","call","m","c","d","name","getter","o","Object","defineProperty","configurable","enumerable","get","n","__esModule","object","property","prototype","hasOwnProperty","p","s","VNode","h","nodeName","attributes","lastSimple","child","simple","children","EMPTY_CHILDREN","arguments","length","stack","push","pop","undefined","String","key","options","vnode","extend","obj","props","cloneElement","slice","enqueueRender","component","_dirty","items","debounceRendering","defer","rerender","list","renderComponent","isSameNodeType","node","hydrating","splitText","_componentConstructor","isNamedNode","normalizedNodeName","toLowerCase","getNodeProps","defaultProps","createNode","isSvg","document","createElementNS","createElement","removeNode","parentNode","removeChild","setAccessor","old","value","style","cssText","_typeof","IS_NON_DIMENSIONAL","test","innerHTML","__html","useCapture","replace","substring","addEventListener","eventProxy","removeEventListener","_listeners","setProperty","removeAttribute","ns","removeAttributeNS","setAttributeNS","setAttribute","className","e","this","type","event","flushMounts","mounts","afterMount","componentDidMount","diff","dom","context","mountAll","parent","componentRoot","diffLevel","isSvgMode","ownerSVGElement","ret","idiff","appendChild","out","prevSvgMode","_component","nodeValue","createTextNode","replaceChild","recollectNodeTree","vnodeName","buildComponentFromVNode","firstChild","fc","vchildren","a","nextSibling","innerDiffNode","dangerouslySetInnerHTML","diffAttributes","isHydrating","j","f","vchild","originalChildren","childNodes","keyed","keyedLen","min","len","childrenLen","vlen","_child","__key","trim","insertBefore","unmountOnly","unmountComponent","ref","removeChildren","lastChild","next","previousSibling","attrs","collectComponent","constructor","components","createComponent","Ctor","inst","render","Component","doRender","nextBase","splice","state","setComponentProps","opts","_disable","__ref","base","componentWillMount","componentWillReceiveProps","prevContext","prevProps","syncComponentUpdates","isChild","rendered","cbase","previousProps","previousState","prevState","previousContext","isUpdate","initialBase","initialChildComponent","skip","shouldComponentUpdate","componentWillUpdate","getChildContext","toUnmount","childComponent","childProps","_parentComponent","baseParent","componentRef","t","unshift","componentDidUpdate","afterUpdate","_renderCallbacks","originalComponent","oldDom","isDirectOwner","isOwner","beforeUnmount","componentWillUnmount","inner","merge","Symbol","iterator","Promise","resolve","then","bind","setTimeout","setState","callback","forceUpdate","preact","default","g","Function","eval","window","bem","blockName","_len","modifiers","Array","_key","concat","filter","Boolean","map","modifier","join","_classCallCheck","instance","Constructor","TypeError","_possibleConstructorReturn","self","ReferenceError","_inherits","subClass","superClass","create","writable","setPrototypeOf","__proto__","connect","mapStateToProps","wrappedComponent","Connected","_Component2","_ref","_temp","_this2","_ret","args","getPrototypeOf","apply","_createClass","_preact","_extends","sendErrorReport","trackAction","displayName","Provider","assign","target","source","defineProperties","descriptor","protoProps","staticProps","_Component","root","app","app--medium","app--large","app--extra-large","_index","_index2","global","Error","setImmediate","noop","fn","thisArg","_state","_handled","_value","_deferreds","doResolve","handle","deferred","_immediateFn","cb","onFulfilled","onRejected","reject","promise","newValue","finale","_unhandledRejectionFn","Handler","done","reason","ex","setTimeoutFunc","prom","all","arr","res","val","remaining","race","values","err","console","warn","Timeout","id","clearFn","_id","_clearFn","clearTimeout","setInterval","clearInterval","timeout","close","unref","enroll","item","msecs","_idleTimeoutId","_idleTimeout","unenroll","_unrefActive","active","_onTimeout","clearImmediate","process","task","tasksByHandle","nextHandle","registerImmediate","run","runIfPresent","currentlyRunningATask","doc","attachTo","toString","nextTick","postMessage","importScripts","postMessageIsAsynchronous","oldOnMessage","onmessage","messagePrefix","Math","random","onGlobalMessage","data","indexOf","attachEvent","MessageChannel","channel","port1","port2","html","documentElement","script","onreadystatechange","defaultSetTimout","defaultClearTimeout","runTimeout","fun","cachedSetTimeout","runClearTimeout","marker","cachedClearTimeout","cleanUpNextTick","draining","currentQueue","queue","queueIndex","drainQueue","Item","array","title","browser","env","argv","version","versions","on","addListener","once","off","removeListener","removeAllListeners","emit","prependListener","prependOnceListener","listeners","binding","cwd","chdir","dir","umask","IntersectionObserverEntry","entry","time","rootBounds","boundingClientRect","intersectionRect","getEmptyRect","isIntersecting","targetRect","targetArea","width","height","intersectionArea","intersectionRatio","IntersectionObserver","opt_options","nodeType","_checkForIntersections","throttle","THROTTLE_TIMEOUT","_callback","_observationTargets","_queuedEntries","_rootMarginValues","_parseRootMargin","rootMargin","thresholds","_initThresholds","threshold","margin","unit","now","performance","timer","addEvent","opt_useCapture","removeEvent","detatchEvent","computeRectIntersection","rect1","rect2","top","max","bottom","left","right","getBoundingClientRect","el","rect","containsDeep","getParentNode","host","registry","POLL_INTERVAL","USE_MUTATION_OBSERVER","observe","some","element","_registerInstance","_monitorIntersections","unobserve","_unmonitorIntersections","_unregisterInstance","disconnect","takeRecords","records","opt_threshold","isArray","sort","isNaN","opt_rootMargin","marginString","margins","split","parts","exec","parseFloat","_monitoringIntersections","_monitoringInterval","_domObserver","MutationObserver","childList","characterData","subtree","rootIsInDom","_rootIsInDom","rootRect","_getRootRect","forEach","rootContainsTarget","_rootContainsTarget","oldEntry","_computeTargetAndRootIntersection","newEntry","_hasCrossedThreshold","getComputedStyle","display","atRoot","parentRect","parentComputedStyle","body","overflow","clientWidth","clientHeight","_expandRectByRootMargin","newRect","oldRatio","newRatio","index","init","findElements","_uuid","uuid","preloadedState","JSON","parse","getAttribute","errorEventTrackingEnabled","simpleErrorReport","_errorReporting","createErrorReporter","listenAndCatch","gaPropertyId","metadata","selfId","published","googleAnalyticsTracker","_dhAnalyticsUtils","createGoogleAnalyticsTracker","publishedDate","Date","_getContextId","getContextId","location","href","message","action","eventObj","category","label","sendEvent","_provider","_App","App","_nodelistToArray","nodelistToArray","getElementsByClassName","_App2","isInitialized","_domready","_domready2","definition","listener","fns","hack","doScroll","loaded","readyState","shift","nodeList","substr","isErrorReportingEnabled","_dhSimpleErrorReport","SimpleErrorReport","url","dryRun","__WEBPACK_AMD_DEFINE_FACTORY__","__WEBPACK_AMD_DEFINE_ARRAY__","__WEBPACK_AMD_DEFINE_RESULT__","r","register","errorRegister","filename","lineno","colno","line","column","log","stringify","isInRegisterWithinRange","addErrorToRegister","XMLHttpRequest","open","setRequestHeader","send","_toConsumableArray","arr2","from","getCurrentBreakpoint","_debounce","_bem","_InfoBox","_Trash","_Sea","_SeaOverlay","_SeaLight","MAX_FPS_COUNT","trackFpsCount","AppComponent","_this","amount","hasIntersected","prefersReducedMotion","speedModifier","breakpoint","interval","observer","debouncedResize","rootEl","overrideXlStyles","allContainers","querySelectorAll","container","querySelector","padding","offsetWidth","offsetHeight","handleReducedMotion","_window$matchMedia","matchMedia","matches","handleFpsUpdate","fps","handleObserve","enteries","_ref2","handleResize","debounce","isXl","_this3","_props","showLink","linkText","class","Sea","Trash","shouldMount","onFpsUpdate","SeaLight","SeaOverlay","InfoBox","func","wait","immediate","later","callNow","_Counter","_InfoBox2","amountInBottles","ceil","toLocaleString","amountInFleece","toFixed","aria-hidden","Counter","afterText","xmlns","viewBox","stroke","fill","strokeLinecap","_Counter2","amountInTon","counter","v","counter__number","app--small","info-box","info-box__inner","info-box__paragraph","info-box__paragraph--darker","info-box__link-button","info-box__big-text","info-box__text-line","_trashController","_Trash2","hasMounted","nextProps","mountTrash","elm","_this$props","trash","trash__fallback","addBodiesWithSprites","composite","numberOfBodies","x","y","choose","bodies","sprite","addBody","xVelocity","yVelocity","_matterJs","Body","setVelocity","World","add","Bodies","rectangle","friction","frictionAir","angle","PI","strokeStyle","texture","base64","xScale","yScale","Common","engine","Engine","Render","wireframes","background","runner","Runner","world","gravity","scale","bodiesToRemove","position","Composite","remove","bodiesFromWidth","isStatic","fillStyle","require","u","code","1","_dereq_","Vertices","Vector","Sleeping","Bounds","Axes","_inertiaScale","_nextCollidingGroupId","_nextNonCollidingGroupId","_nextCategory","defaults","nextId","plugin","vertices","fromPath","force","torque","positionImpulse","constraintImpulse","totalContacts","speed","angularSpeed","velocity","angularVelocity","isSensor","isSleeping","motion","sleepThreshold","density","restitution","frictionStatic","collisionFilter","mask","group","slop","timeScale","visible","opacity","xOffset","yOffset","lineWidth","_initProperties","nextGroup","isNonColliding","nextCategory","set","bounds","positionPrev","clone","anglePrev","rotate","axes","update","area","mass","inertia","defaultFillStyle","settings","setStatic","setMass","setDensity","setInertia","setVertices","setPosition","setAngle","setAngularVelocity","setParts","part","_original","inverseMass","inverseInertia","Infinity","moment","fromVertices","centre","translate","autoHull","clockwiseSort","hull","hullCentre","total","_totalProperties","delta","sub","rotateAbout","magnitude","abs","translation","rotation","point","cos","sin","dx","dy","scaleX","scaleY","totalArea","totalInertia","circleRadius","deltaTime","correction","deltaTimeSquared","pow","velocityPrevX","velocityPrevY","applyForce","offset","properties","mult","div","../core/Common","../core/Sleeping","../geometry/Axes","../geometry/Bounds","../geometry/Vector","../geometry/Vertices","../render/Render","2","Events","isModified","constraints","composites","setModified","updateParents","updateChildren","childComposite","objects","trigger","addConstraint","addComposite","constraint","deep","removeBody","removeConstraint","removeComposite","compositeA","compositeB","removeCompositeAt","removeBodyAt","removeConstraintAt","clear","keepStatic","allBodies","allConstraints","allComposites","move","rebase","recursive","Matter","../core/Events","./Body","3","../constraint/Constraint","./Composite","4","Contact","vertex","normalImpulse","tangentImpulse","5","Detector","SAT","Pair","collisions","broadphasePairs","pairsTable","pairs","table","bodyA","bodyB","canCollide","overlaps","partA","k","partB","previousCollision","pairId","pair","isActive","collision","collides","collided","filterA","filterB","./Pair","./SAT","6","Grid","controller","detector","buckets","pairsList","bucketWidth","bucketHeight","grid","col","row","bucket","bucketId","gridChanged","newRegion","_getRegion","region","union","_regionUnion","startCol","endCol","startRow","endRow","_getBucketId","isInsideNewRegion","isInsideOldRegion","_bucketRemoveBody","_createBucket","_bucketAddBody","_createActivePairsList","regionA","regionB","_createRegion","floor","pairKeys","keys","./Detector","7","timestamp","parentA","parentB","contacts","activeContacts","separation","timeCreated","timeUpdated","supports","support","contactId","contact","depth","setActive","./Contact","8","Pairs","_pairMaxIdleLife","collisionStart","collisionActive","collisionEnd","activePairIds","removeOld","pairIndex","indexesToRemove","9","Query","ray","startPoint","endPoint","rayWidth","rayAngle","rayLength","rayX","rayY","outside","result","contains","../factory/Bodies","10","Resolver","_restingThresh","_restingThreshTangent","_positionDampen","_positionWarming","_frictionNormalMultiplier","preSolvePosition","activeCount","solvePosition","normal","bodyBtoA","contactShare","tempA","tempB","tempC","tempD","penetration","dot","postSolvePosition","preSolveVelocity","tangent","contactVertex","impulse","cross","solveVelocity","timeScaleSquared","tempE","offsetA","offsetB","velocityPointA","perp","velocityPointB","relativeVelocity","normalVelocity","tangentVelocity","tangentSpeed","tangentVelocityDirection","sign","normalForce","clamp","maxFriction","oAcN","oBcN","share","contactNormalImpulse","contactTangentImpulse","11","overlapAB","overlapBA","minOverlap","canReusePrevCol","axisBodyA","axisBody","axisBodyB","axisNumber","_overlapAxes","reused","overlap","axis","verticesB","_findSupports","verticesA","neg","projectionA","projectionB","Number","MAX_VALUE","_projectToAxis","projection","distance","vertexA","vertexB","nearestDistance","vertexToBody","bodyAPosition","12","Constraint","_warming","_torqueDampen","_minLength","pointA","pointB","initialPointA","initialPointB","stiffness","damping","angularStiffness","angleA","angleB","anchors","preSolveAll","solveAll","fixedA","fixedB","solve","pointAWorld","pointBWorld","currentLength","difference","massTotal","inertiaTotal","resistanceTotal","zero","postSolveAll","13","MouseConstraint","Mouse","mouse","canvas","mouseConstraint","_triggerEvents","button","mouseEvents","sourceEvents","mousemove","mousedown","mouseup","clearSourceEvents","../body/Composite","../collision/Detector","../core/Mouse","./Constraint","14","_nextId","_seed","_nowStartTime","argsStart","deepClone","prop","path","begin","end","shuffle","temp","choices","isElement","HTMLElement","isFunction","isPlainObject","isString","webkitNow","_seededRandom","colorToNumber","colorString","charAt","parseInt","logLevel","info","haystack","needle","mapped","topologicalSort","graph","visited","_topologicalSort","neighbors","neighbor","chain","funcs","_chained","lastResult","chainPathBefore","chainPathAfter","15","positionIterations","velocityIterations","constraintIterations","enableSleeping","events","timing","broadphase","renderDefaults","metrics","extended","_bodiesApplyGravity","_bodiesUpdate","afterCollisions","_bodiesClearForces","engineA","engineB","gravityScale","worldBounds","../body/Body","../body/World","../collision/Grid","../collision/Pairs","../collision/Resolver","./Common","./Events","./Metrics","./Sleeping","16","eventNames","names","callbacks","newCallbacks","eventClone","17","Plugin","uses","used","use","before","after","./Plugin","18","19","absolute","mousedownPosition","mouseupPosition","wheelDelta","pixelRatio","mousewheel","_getRelativeMousePosition","changedTouches","preventDefault","detail","setElement","setOffset","setScale","elementBounds","rootNode","scrollX","pageXOffset","scrollLeft","scrollY","pageYOffset","scrollTop","touches","pageX","pageY","20","_registry","isPlugin","registered","pluginVersion","versionParse","number","registeredVersion","dependency","dependencyParse","range","install","isUsed","isFor","parsed","for","versionSatisfies","plugins","dependencies","sortedDependencies","status","_warned","tracked","parsedBase","resolved","identifiers","isRange","operator","prerelease","rangeParsed","rangeParts","versionParsed","versionParts","21","_requestAnimationFrame","_cancelAnimationFrame","requestAnimationFrame","webkitRequestAnimationFrame","mozRequestAnimationFrame","msRequestAnimationFrame","cancelAnimationFrame","mozCancelAnimationFrame","webkitCancelAnimationFrame","msCancelAnimationFrame","_frameTimeout","deltaSampleSize","counterTimestamp","frameCounter","deltaHistory","timePrev","timeScalePrev","frameRequestId","isFixed","enabled","deltaMin","deltaMax","tick","stop","start","./Engine","22","_motionWakeThreshold","_motionSleepThreshold","_minBias","timeFactor","minMotion","maxMotion","sleepCounter","sleepingBody","movingBody","wasSleeping","23","decomp","chamfer","radius","quality","qualityMin","qualityMax","trapezoid","slope","verticesPath","roof","x1","x2","x3","circle","maxSides","sides","polygon","theta","xx","yy","vertexSets","flagInternal","removeCollinear","minimumArea","isConvex","z","concave","makeCCW","removeCollinearPoints","decomposed","quickDecomp","chunk","chunkVertices","pav","pbv","da","magnitudeSquared","db","isInternal","24","Composites","columns","rows","columnGap","rowGap","lastBody","maxHeight","bodyHeight","bodyWidth","xOffsetA","yOffsetA","xOffsetB","yOffsetB","bodyAHeight","bodyAWidth","bodyBHeight","bodyBWidth","mesh","crossBrace","bodyC","pyramid","actualRows","lastBodyWidth","newtonsCradle","size","car","wheelSize","wheelAOffset","wheelBOffset","wheelA","wheelB","axelA","axelB","softBody","particleRadius","particleOptions","constraintOptions","./Bodies","25","normalise","gradient","26","boundsA","boundsB","vector","deltaX","deltaY","27","Svg","pathToVertices","sampleLength","il","segment","segments","segmentsQueue","lastSegment","lastPoint","segmentIndex","lx","ly","points","addPoint","px","py","pathSegType","isRelative","addSegmentPoint","segType","pathSegTypeAsLetter","toUpperCase","_svgPathToAbsolute","getTotalLength","pathSegList","numberOfItems","getItem","getPathSegAtLength","getPointAtLength","x0","y0","y1","y2","segs","seg","replaceItem","createSVGPathSegMovetoAbs","createSVGPathSegLinetoAbs","createSVGPathSegLinetoHorizontalAbs","createSVGPathSegLinetoVerticalAbs","createSVGPathSegCurvetoCubicAbs","createSVGPathSegCurvetoCubicSmoothAbs","createSVGPathSegCurvetoQuadraticAbs","createSVGPathSegCurvetoQuadraticSmoothAbs","createSVGPathSegArcAbs","r1","r2","largeArcFlag","sweepFlag","28","sqrt","output","vectorA","vectorB","cross3","vectorC","scalar","negate","atan2","29","pathPattern","match","mean","average","signed","numerator","denominator","vertice","nextVertice","newVertices","prevVertex","nextVertex","currentRadius","prevNormal","nextNormal","diagonalRadius","radiusVector","midNormal","scaledVertex","precision","alpha","acos","flag","upper","lower","30","RenderPixi","../collision/Contact","../collision/Pair","../collision/Query","../collision/SAT","../constraint/MouseConstraint","../core/Engine","../core/Matter","../core/Metrics","../core/Plugin","../core/Runner","../factory/Composites","../geometry/Svg","../render/RenderPixi","31","wireframeBackground","hasBounds","showSleeping","showDebug","showBroadphase","showBounds","showVelocity","showCollisions","showSeparations","showAxes","showPositions","showAngleIndicator","showIds","showShadows","showVertexNumbers","showConvexHulls","showInternalEdges","showMousePosition","_createCanvas","getContext","textures","setPixelRatio","loop","_getPixelRatio","lookAt","center","viewHeight","viewWidth","outerRatio","innerRatio","startViewTransform","boundsWidth","boundsHeight","boundsScaleX","boundsScaleY","endViewTransform","setTransform","currentBackground","_applyBackground","globalCompositeOperation","fillRect","bodyConvexHulls","bodyWireframes","bodyBounds","bodyAxes","bodyPositions","bodyVelocity","bodyIds","separations","vertexNumbers","mousePosition","debug","debugTimestamp","text","round","debugString","font","fillText","beginPath","arc","closePath","moveTo","coils","lineTo","bodyShadows","distanceX","distanceY","shadowColor","shadowOffsetX","shadowOffsetY","shadowBlur","globalAlpha","_getTexture","drawImage","normalPosX","normalPosY","bucketKeys","inspector","selected","setLineDash","selectStart","selectBounds","oncontextmenu","onselectstart","devicePixelRatio","webkitBackingStorePixelRatio","mozBackingStorePixelRatio","msBackingStorePixelRatio","oBackingStorePixelRatio","backingStorePixelRatio","imagePath","image","Image","src","cssBackground","backgroundSize","32","renderer","spriteContainer","pixiOptions","transparent","view","antialias","backgroundColor","PIXI","WebGLRenderer","Container","sprites","primitives","addChild","bgSprite","addChildAt","setBackground","isColor","color","Sprite","constraintRender","primitiveId","primitive","Graphics","beginFill","lineStyle","endFill","bodyRender","spriteId","_createBodySprite","_createBodyPrimitive","initialAngle","texturePath","anchor","strokeStyleIndicator","strokeStyleWireframe","strokeStyleWireframeIndicator","Texture","fromImage","trash--active","trash__fallback-top","trash__fallback-body","_Sea2","sea","sea__waves","app--has-intersected","sea__flowers","_SeaOverlay2","sea-overlay","_SeaLight2","sea-light","ga","w","referrer","dimension1","dimension2","dimension3","getFullYear","dimension4","getMonth","dimension5","getDate","dimension6","dimension7","dimension10","trackingId","cookieDomain","eventCategory","eventAction","eventLabel","eventValue","nonInteraction","fieldsObject","extractPolopolyIdFromString","str","POLOPOLY_ID_REGEX"],"mappings":"CAAS,SAAUA,GCInB,QAAAC,GAAAC,GAGA,GAAAC,EAAAD,GACA,MAAAC,GAAAD,GAAAE,OAGA,IAAAC,GAAAF,EAAAD,IACAI,EAAAJ,EACAK,GAAA,EACAH,WAUA,OANAJ,GAAAE,GAAAM,KAAAH,EAAAD,QAAAC,IAAAD,QAAAH,GAGAI,EAAAE,GAAA,EAGAF,EAAAD,QAvBA,GAAAD,KA4BAF,GAAAQ,EAAAT,EAGAC,EAAAS,EAAAP,EAGAF,EAAAU,EAAA,SAAAP,EAAAQ,EAAAC,GACAZ,EAAAa,EAAAV,EAAAQ,IACAG,OAAAC,eAAAZ,EAAAQ,GACAK,cAAA,EACAC,YAAA,EACAC,IAAAN,KAMAZ,EAAAmB,EAAA,SAAAf,GACA,GAAAQ,GAAAR,KAAAgB,WACA,WAA2B,MAAAhB,GAAA,SAC3B,WAAiC,MAAAA,GAEjC,OADAJ,GAAAU,EAAAE,EAAA,IAAAA,GACAA,GAIAZ,EAAAa,EAAA,SAAAQ,EAAAC,GAAsD,MAAAR,QAAAS,UAAAC,eAAAjB,KAAAc,EAAAC,IAGtDtB,EAAAyB,EAAA,sDAGAzB,IAAA0B,EAAA,KDMM,SAAUtB,EAAQD,EAASH,GAEjC,YEpEA,SAAS2B,MA8DT,QAASC,GAAEC,EAAUC,GACpB,GACIC,GACAC,EACAC,EACA5B,EAJA6B,EAAWC,CAKf,KAAK9B,EAAI+B,UAAUC,OAAQhC,KAAM,GAChCiC,EAAMC,KAAKH,UAAU/B,GAMtB,KAJIyB,GAAqC,MAAvBA,EAAWI,WACvBI,EAAMD,QAAQC,EAAMC,KAAKT,EAAWI,gBAClCJ,GAAWI,UAEZI,EAAMD,QACZ,IAAKL,EAAQM,EAAME,YAAwBC,KAAdT,EAAMQ,IAClC,IAAKnC,EAAI2B,EAAMK,OAAQhC,KACtBiC,EAAMC,KAAKP,EAAM3B,QAGG,iBAAV2B,KAAqBA,EAAQ,OAEpCC,EAA6B,kBAAbJ,MACN,MAATG,EAAeA,EAAQ,GAA6B,gBAAVA,GAAoBA,EAAQU,OAAOV,GAAiC,gBAAVA,KAAoBC,GAAS,IAGlIA,GAAUF,EACbG,EAASA,EAASG,OAAS,IAAML,EACvBE,IAAaC,EACvBD,GAAYF,GAEZE,EAASK,KAAKP,GAGfD,EAAaE,CAIf,IAAIR,GAAI,GAAIE,EASZ,OARAF,GAAEI,SAAWA,EACbJ,EAAES,SAAWA,EACbT,EAAEK,WAA2B,MAAdA,MAAqBW,GAAYX,EAChDL,EAAEkB,IAAoB,MAAdb,MAAqBW,GAAYX,EAAWa,QAG9BF,KAAlBG,EAAQC,OAAqBD,EAAQC,MAAMpB,GAExCA,EAUR,QAASqB,GAAOC,EAAKC,GACnB,IAAK,GAAI3C,KAAK2C,GACZD,EAAI1C,GAAK2C,EAAM3C,EAChB,OAAO0C,GAkBV,QAASE,GAAaJ,EAAOG,GAC3B,MAAOpB,GAAEiB,EAAMhB,SAAUiB,EAAOA,KAAWD,EAAMf,YAAakB,GAAQZ,UAAUC,OAAS,KAAOa,MAAM3C,KAAK6B,UAAW,GAAKS,EAAMX,UAUnI,QAASiB,GAAcC,IACjBA,EAAUC,SAAWD,EAAUC,QAAS,IAAkC,GAAzBC,EAAMf,KAAKa,KAC/DR,EAAQW,mBAAqBC,GAAOC,GAIvC,QAASA,KACR,GAAIhC,GACAiC,EAAOJ,CAEX,KADAA,KACO7B,EAAIiC,EAAKlB,OACXf,EAAE4B,QAAQM,EAAgBlC,GAYhC,QAASmC,GAAeC,EAAMhB,EAAOiB,GACnC,MAAqB,gBAAVjB,IAAuC,gBAAVA,OACZJ,KAAnBoB,EAAKE,UAEgB,gBAAnBlB,GAAMhB,UACPgC,EAAKG,uBAAyBC,EAAYJ,EAAMhB,EAAMhB,UAEzDiC,GAAaD,EAAKG,wBAA0BnB,EAAMhB,SAS3D,QAASoC,GAAYJ,EAAMhC,GACzB,MAAOgC,GAAKK,qBAAuBrC,GAAYgC,EAAKhC,SAASsC,gBAAkBtC,EAASsC,cAW1F,QAASC,GAAavB,GACpB,GAAIG,GAAQF,KAAWD,EAAMf,WAC7BkB,GAAMd,SAAWW,EAAMX,QAEvB,IAAImC,GAAexB,EAAMhB,SAASwC,YAClC,QAAqB5B,KAAjB4B,EACF,IAAK,GAAIhE,KAAKgE,OACK5B,KAAbO,EAAM3C,KACR2C,EAAM3C,GAAKgE,EAAahE,GAK9B,OAAO2C,GAQT,QAASsB,GAAWzC,EAAU0C,GAC7B,GAAIV,GAAOU,EAAQC,SAASC,gBAAgB,6BAA8B5C,GAAY2C,SAASE,cAAc7C,EAE7G,OADAgC,GAAKK,mBAAqBrC,EACnBgC,EAMR,QAASc,GAAWd,GACnB,GAAIe,GAAaf,EAAKe,UAClBA,IAAYA,EAAWC,YAAYhB,GAYxC,QAASiB,GAAYjB,EAAMlD,EAAMoE,EAAKC,EAAOT,GAG5C,GAFa,cAAT5D,IAAsBA,EAAO,SAEpB,QAATA,OAEG,IAAa,QAATA,EACNoE,GAAKA,EAAI,MACTC,GAAOA,EAAMnB,OACX,IAAa,UAATlD,GAAqB4D,EAEzB,GAAa,UAAT5D,GAIV,GAHKqE,GAA0B,gBAAVA,IAAqC,gBAARD,KACjDlB,EAAKoB,MAAMC,QAAUF,GAAS,IAE3BA,GAA0B,gBAAjB,KAAOA,EAAP,YAAAG,EAAOH,IAAoB,CACvC,GAAmB,gBAARD,GACV,IAAK,GAAI1E,KAAK0E,GACP1E,IAAK2E,KAAQnB,EAAKoB,MAAM5E,GAAK,GAGrC,KAAK,GAAIA,KAAK2E,GACbnB,EAAKoB,MAAM5E,GAAyB,gBAAb2E,GAAM3E,KAAkD,IAA/B+E,EAAmBC,KAAKhF,GAAe2E,EAAM3E,GAAK,KAAO2E,EAAM3E,QAG3G,IAAa,4BAATM,EACNqE,IAAOnB,EAAKyB,UAAYN,EAAMO,QAAU,QACtC,IAAe,KAAX5E,EAAK,IAAwB,KAAXA,EAAK,GAAW,CAC5C,GAAI6E,GAAa7E,KAAUA,EAAOA,EAAK8E,QAAQ,WAAY,IAC3D9E,GAAOA,EAAKwD,cAAcuB,UAAU,GAChCV,EACED,GAAKlB,EAAK8B,iBAAiBhF,EAAMiF,EAAYJ,GAElD3B,EAAKgC,oBAAoBlF,EAAMiF,EAAYJ,IAE3C3B,EAAKiC,aAAejC,EAAKiC,gBAAkBnF,GAAQqE,MAC9C,IAAa,SAATrE,GAA4B,SAATA,IAAoB4D,GAAS5D,IAAQkD,GAClEkC,EAAYlC,EAAMlD,EAAe,MAATqE,EAAgB,GAAKA,GAChC,MAATA,IAA2B,IAAVA,GAAiBnB,EAAKmC,gBAAgBrF,OACrD,CACN,GAAIsF,GAAK1B,GAAS5D,KAAUA,EAAOA,EAAK8E,QAAQ,YAAa,IAChD,OAATT,IAA2B,IAAVA,EAChBiB,EAAIpC,EAAKqC,kBAAkB,+BAAgCvF,EAAKwD,eAAoBN,EAAKmC,gBAAgBrF,GAClF,kBAAVqE,KACbiB,EAAIpC,EAAKsC,eAAe,+BAAgCxF,EAAKwD,cAAea,GAAYnB,EAAKuC,aAAazF,EAAMqE,QAlCrHnB,GAAKwC,UAAYrB,GAAS,GA0C5B,QAASe,GAAYlC,EAAMlD,EAAMqE,GAChC,IACCnB,EAAKlD,GAAQqE,EACZ,MAAOsB,KAMV,QAASV,GAAWU,GACnB,MAAOC,MAAKT,WAAWQ,EAAEE,MAAM5D,EAAQ6D,OAAS7D,EAAQ6D,MAAMH,IAAMA,GAgBrE,QAASI,KAER,IADA,GAAIjG,GACGA,EAAIkG,EAAOnE,OACbI,EAAQgE,YAAYhE,EAAQgE,WAAWnG,GACvCA,EAAEoG,mBAAmBpG,EAAEoG,oBAU7B,QAASC,GAAKC,EAAKlE,EAAOmE,EAASC,EAAUC,EAAQC,GAE/CC,MAEJC,EAAsB,MAAVH,OAA6CzE,KAA3ByE,EAAOI,gBAGrCxD,EAAmB,MAAPiD,KAAiB,iBAAmBA,IAGjD,IAAIQ,GAAMC,EAAMT,EAAKlE,EAAOmE,EAASC,EAAUE,EAY/C,OATID,IAAUK,EAAI3C,aAAesC,GAAQA,EAAOO,YAAYF,KAGpDH,IACPtD,GAAY,EAEPqD,GAAeT,KAGda,EAIR,QAASC,GAAMT,EAAKlE,EAAOmE,EAASC,EAAUE,GAC7C,GAAIO,GAAMX,EACNY,EAAcN,CAMlB,IAHa,MAATxE,GAAkC,iBAAVA,KAAqBA,EAAQ,IAGpC,gBAAVA,IAAuC,gBAAVA,GAmBvC,MAhBIkE,QAAyBtE,KAAlBsE,EAAIhD,WAA2BgD,EAAInC,cAAgBmC,EAAIa,YAAcT,GAE3EJ,EAAIc,WAAahF,IACpBkE,EAAIc,UAAYhF,IAIjB6E,EAAMlD,SAASsD,eAAejF,GAC1BkE,IACCA,EAAInC,YAAYmC,EAAInC,WAAWmD,aAAaL,EAAKX,GACrDiB,EAAkBjB,GAAK,KAIzBW,EAAA,eAAuB,EAEhBA,CAIR,IAAIO,GAAYpF,EAAMhB,QACtB,IAAyB,kBAAdoG,GACV,MAAOC,GAAwBnB,EAAKlE,EAAOmE,EAASC,EAQrD,IAJAI,EAA0B,QAAdY,GAA2C,kBAAdA,GAAwCZ,EAGjFY,EAAYvF,OAAOuF,KACdlB,IAAQ9C,EAAY8C,EAAKkB,MAC7BP,EAAMpD,EAAW2D,EAAWZ,GAExBN,GAAK,CAER,KAAOA,EAAIoB,YACVT,EAAID,YAAYV,EAAIoB,WAEjBpB,GAAInC,YAAYmC,EAAInC,WAAWmD,aAAaL,EAAKX,GAGrDiB,EAAkBjB,GAAK,GAIzB,GAAIqB,GAAKV,EAAIS,WACTnF,EAAQ0E,EAAA,cACRW,EAAYxF,EAAMX,QAEtB,IAAa,MAATc,EAAe,CAClBA,EAAQ0E,EAAA,gBACR,KAAK,GAAIY,GAAIZ,EAAI5F,WAAYzB,EAAIiI,EAAEjG,OAAQhC,KAC1C2C,EAAMsF,EAAEjI,GAAGM,MAAQ2H,EAAEjI,GAAG2E,MAqB1B,OAhBKlB,GAAauE,GAAkC,IAArBA,EAAUhG,QAAwC,gBAAjBgG,GAAU,IAAyB,MAAND,OAA+B3F,KAAjB2F,EAAGrE,WAA6C,MAAlBqE,EAAGG,YACvIH,EAAGP,WAAaQ,EAAU,KAC7BD,EAAGP,UAAYQ,EAAU,KAIlBA,GAAaA,EAAUhG,QAAgB,MAAN+F,IACxCI,EAAcd,EAAKW,EAAWrB,EAASC,EAAUnD,GAA8C,MAAjCd,EAAMyF,yBAItEC,EAAehB,EAAK7E,EAAMf,WAAYkB,GAGtCqE,EAAYM,EAELD,EAUR,QAASc,GAAczB,EAAKsB,EAAWrB,EAASC,EAAU0B,GACzD,GAQIC,GACAnI,EACAoI,EACAC,EACA9G,EAZA+G,EAAmBhC,EAAIiC,WACvB9G,KACA+G,KACAC,EAAW,EACXC,EAAM,EACNC,EAAML,EAAiB1G,OACvBgH,EAAc,EACdC,EAAOjB,EAAYA,EAAUhG,OAAS,CAQ1C,IAAY,IAAR+G,EACH,IAAK,GAAI/I,GAAI,EAAGA,EAAI+I,EAAK/I,IAAK,CAC7B,GAAIkJ,GAASR,EAAiB1I,GAC1B2C,EAAQuG,EAAA,cACR5G,EAAM2G,GAAQtG,EAAQuG,EAAO3B,WAAa2B,EAAO3B,WAAW4B,MAAQxG,EAAML,IAAM,IACzE,OAAPA,GACHuG,IACAD,EAAMtG,GAAO4G,IACHvG,QAA+BP,KAArB8G,EAAOxF,WAA0B4E,GAAcY,EAAO1B,UAAU4B,OAAgBd,MACpGzG,EAASmH,KAAiBE,GAK7B,GAAa,IAATD,EACH,IAAK,GAAIjJ,GAAI,EAAGA,EAAIiJ,EAAMjJ,IAAK,CAC9ByI,EAAST,EAAUhI,GACnB2B,EAAQ,IAGR,IAAIW,GAAMmG,EAAOnG,GACjB,IAAW,MAAPA,EACCuG,OAA2BzG,KAAfwG,EAAMtG,KACrBX,EAAQiH,EAAMtG,GACdsG,EAAMtG,OAAOF,GACbyG,SAIG,KAAKlH,GAASmH,EAAME,EACvB,IAAKT,EAAIO,EAAKP,EAAIS,EAAaT,IAC9B,OAAoBnG,KAAhBP,EAAS0G,IAAoBhF,EAAenD,EAAIyB,EAAS0G,GAAIE,EAAQH,GAAc,CACtF3G,EAAQvB,EACRyB,EAAS0G,OAAKnG,GACVmG,IAAMS,EAAc,GAAGA,IACvBT,IAAMO,GAAKA,GACf,OAMJnH,EAAQwF,EAAMxF,EAAO8G,EAAQ9B,EAASC,GAEtC4B,EAAIE,EAAiB1I,GACjB2B,GAASA,IAAU+E,GAAO/E,IAAU6G,IAC9B,MAALA,EACH9B,EAAIU,YAAYzF,GACNA,IAAU6G,EAAEN,YACtB5D,EAAWkE,GAEX9B,EAAI2C,aAAa1H,EAAO6G,IAO5B,GAAIK,EACH,IAAK,GAAI7I,KAAK4I,OACIxG,KAAbwG,EAAM5I,IAAkB2H,EAAkBiB,EAAM5I,IAAI,EAK1D,MAAO8I,GAAOE,OAC6B5G,MAArCT,EAAQE,EAASmH,OAA+BrB,EAAkBhG,GAAO,GAQhF,QAASgG,GAAkBnE,EAAM8F,GAChC,GAAIvG,GAAYS,EAAK+D,UACjBxE,GAEHwG,EAAiBxG,IAIY,MAAzBS,EAAA,eAAiCA,EAAA,cAAsBgG,KAAKhG,EAAA,cAAsBgG,IAAI,OAEtE,IAAhBF,GAAkD,MAAzB9F,EAAA,eAC5Bc,EAAWd,GAGZiG,EAAejG,IAQjB,QAASiG,GAAejG,GAEvB,IADAA,EAAOA,EAAKkG,UACLlG,GAAM,CACZ,GAAImG,GAAOnG,EAAKoG,eAChBjC,GAAkBnE,GAAM,GACxBA,EAAOmG,GAST,QAAStB,GAAe3B,EAAKmD,EAAOnF,GACnC,GAAIpE,EAGJ,KAAKA,IAAQoE,GACNmF,GAAwB,MAAfA,EAAMvJ,IAA+B,MAAboE,EAAIpE,IAC1CmE,EAAYiC,EAAKpG,EAAMoE,EAAIpE,GAAOoE,EAAIpE,OAAQ8B,GAAW4E,EAK3D,KAAK1G,IAAQuJ,GACC,aAATvJ,GAAgC,cAATA,GAA2BA,IAAQoE,IAAQmF,EAAMvJ,MAAoB,UAATA,GAA6B,YAATA,EAAqBoG,EAAIpG,GAAQoE,EAAIpE,KAC/ImE,EAAYiC,EAAKpG,EAAMoE,EAAIpE,GAAOoE,EAAIpE,GAAQuJ,EAAMvJ,GAAO0G,GAY9D,QAAS8C,GAAiB/G,GACzB,GAAIzC,GAAOyC,EAAUgH,YAAYzJ,MAChC0J,EAAW1J,KAAU0J,EAAW1J,QAAa4B,KAAKa,GAIpD,QAASkH,GAAgBC,EAAMvH,EAAOgE,GACrC,GACIwD,GADA9G,EAAO2G,EAAWE,EAAK5J,KAY3B,IATI4J,EAAKhJ,WAAagJ,EAAKhJ,UAAUkJ,QACpCD,EAAO,GAAID,GAAKvH,EAAOgE,GACvB0D,EAAUnK,KAAKiK,EAAMxH,EAAOgE,KAE5BwD,EAAO,GAAIE,GAAU1H,EAAOgE,GAC5BwD,EAAKJ,YAAcG,EACnBC,EAAKC,OAASE,GAGXjH,EACH,IAAK,GAAIrD,GAAIqD,EAAKrB,OAAQhC,KACzB,GAAIqD,EAAKrD,GAAG+J,cAAgBG,EAAM,CACjCC,EAAKI,SAAWlH,EAAKrD,GAAGuK,SACxBlH,EAAKmH,OAAOxK,EAAG,EACf,OAIH,MAAOmK,GAIR,QAASG,GAAS3H,EAAO8H,EAAO9D,GAC/B,MAAOT,MAAK6D,YAAYpH,EAAOgE,GAShC,QAAS+D,GAAkB3H,EAAWJ,EAAOgI,EAAMhE,EAASC,GACvD7D,EAAU6H,WACd7H,EAAU6H,UAAW,GAEjB7H,EAAU8H,MAAQlI,EAAM6G,YAAY7G,GAAM6G,KAC1CzG,EAAUoG,MAAQxG,EAAML,YAAYK,GAAML,KAEzCS,EAAU+H,MAAQlE,EAClB7D,EAAUgI,oBAAoBhI,EAAUgI,qBAClChI,EAAUiI,2BACpBjI,EAAUiI,0BAA0BrI,EAAOgE,GAGxCA,GAAWA,IAAY5D,EAAU4D,UAC/B5D,EAAUkI,cAAalI,EAAUkI,YAAclI,EAAU4D,SAC9D5D,EAAU4D,QAAUA,GAGhB5D,EAAUmI,YAAWnI,EAAUmI,UAAYnI,EAAUJ,OAC1DI,EAAUJ,MAAQA,EAElBI,EAAU6H,UAAW,EAER,IAATD,IACU,IAATA,IAA+C,IAAjCpI,EAAQ4I,sBAAmCpI,EAAU+H,KAGtEhI,EAAcC,GAFdO,EAAgBP,EAAW,EAAG6D,IAM5B7D,EAAU8H,OAAO9H,EAAU8H,MAAM9H,IAStC,QAASO,GAAgBP,EAAW4H,EAAM/D,EAAUwE,GACnD,IAAIrI,EAAU6H,SAAd,CAEA,GAWIS,GACAlB,EACAmB,EAbA3I,EAAQI,EAAUJ,MAClB8H,EAAQ1H,EAAU0H,MAClB9D,EAAU5D,EAAU4D,QACpB4E,EAAgBxI,EAAUmI,WAAavI,EACvC6I,EAAgBzI,EAAU0I,WAAahB,EACvCiB,EAAkB3I,EAAUkI,aAAetE,EAC3CgF,EAAW5I,EAAU+H,KACrBP,EAAWxH,EAAUwH,SACrBqB,EAAcD,GAAYpB,EAC1BsB,EAAwB9I,EAAUwE,WAClCuE,GAAO,CAuBX,IAjBIH,IACH5I,EAAUJ,MAAQ4I,EAClBxI,EAAU0H,MAAQe,EAClBzI,EAAU4D,QAAU+E,EACP,IAATf,GAAc5H,EAAUgJ,wBAAoF,IAA3DhJ,EAAUgJ,sBAAsBpJ,EAAO8H,EAAO9D,GAClGmF,GAAO,EACG/I,EAAUiJ,qBACpBjJ,EAAUiJ,oBAAoBrJ,EAAO8H,EAAO9D,GAE7C5D,EAAUJ,MAAQA,EAClBI,EAAU0H,MAAQA,EAClB1H,EAAU4D,QAAUA,GAGrB5D,EAAUmI,UAAYnI,EAAU0I,UAAY1I,EAAUkI,YAAclI,EAAUwH,SAAW,KACzFxH,EAAUC,QAAS,GAEd8I,EAAM,CACVT,EAAWtI,EAAUqH,OAAOzH,EAAO8H,EAAO9D,GAGtC5D,EAAUkJ,kBACbtF,EAAUlE,EAAOA,KAAWkE,GAAU5D,EAAUkJ,mBAGjD,IACIC,GACApB,EAFAqB,EAAiBd,GAAYA,EAAS7J,QAI1C,IAA8B,kBAAnB2K,GAA+B,CAGzC,GAAIC,GAAarI,EAAasH,EAC9BlB,GAAO0B,EAEH1B,GAAQA,EAAKJ,cAAgBoC,GAAkBC,EAAW9J,KAAO6H,EAAKhB,MACzEuB,EAAkBP,EAAMiC,EAAY,EAAGzF,GAAS,IAEhDuF,EAAY/B,EAEZpH,EAAUwE,WAAa4C,EAAOF,EAAgBkC,EAAgBC,EAAYzF,GAC1EwD,EAAKI,SAAWJ,EAAKI,UAAYA,EACjCJ,EAAKkC,iBAAmBtJ,EACxB2H,EAAkBP,EAAMiC,EAAY,EAAGzF,GAAS,GAChDrD,EAAgB6G,EAAM,EAAGvD,GAAU,IAGpCkE,EAAOX,EAAKW,SAEZQ,GAAQM,EAGRM,EAAYL,EACRK,IACHZ,EAAQvI,EAAUwE,WAAa,OAG5BqE,GAAwB,IAATjB,KACdW,IAAOA,EAAM/D,WAAa,MAC9BuD,EAAOrE,EAAK6E,EAAOD,EAAU1E,EAASC,IAAa+E,EAAUC,GAAeA,EAAYrH,YAAY,GAItG,IAAIqH,GAAed,IAASc,GAAezB,IAAS0B,EAAuB,CAC1E,GAAIS,GAAaV,EAAYrH,UACzB+H,IAAcxB,IAASwB,IAC1BA,EAAW5E,aAAaoD,EAAMc,GAEzBM,IACJN,EAAYrE,WAAa,KACzBI,EAAkBiE,GAAa,KAUlC,GALIM,GACH3C,EAAiB2C,GAGlBnJ,EAAU+H,KAAOA,EACbA,IAASM,EAAS,CAGrB,IAFA,GAAImB,GAAexJ,EACfyJ,EAAIzJ,EACDyJ,EAAIA,EAAEH,mBACXE,EAAeC,GAAG1B,KAAOA,CAE3BA,GAAKvD,WAAagF,EAClBzB,EAAKnH,sBAAwB4I,EAAaxC,aAkB5C,IAdK4B,GAAY/E,EAChBN,EAAOmG,QAAQ1J,GACJ+I,IAMP/I,EAAU2J,oBACb3J,EAAU2J,mBAAmBnB,EAAeC,EAAeE,GAExDnJ,EAAQoK,aAAapK,EAAQoK,YAAY5J,IAGZ,MAA9BA,EAAU6J,iBACb,KAAO7J,EAAU6J,iBAAiB5K,QACjCe,EAAU6J,iBAAiBzK,MAAMjC,KAAK6C,EAInCgE,IAAcqE,GAAS/E,KAS7B,QAASwB,GAAwBnB,EAAKlE,EAAOmE,EAASC,GAOrD,IANA,GAAIxG,GAAIsG,GAAOA,EAAIa,WACfsF,EAAoBzM,EACpB0M,EAASpG,EACTqG,EAAgB3M,GAAKsG,EAAI/C,wBAA0BnB,EAAMhB,SACzDwL,EAAUD,EACVpK,EAAQoB,EAAavB,GAClBpC,IAAM4M,IAAY5M,EAAIA,EAAEiM,mBAC9BW,EAAU5M,EAAE2J,cAAgBvH,EAAMhB,QA2BnC,OAxBIpB,IAAK4M,KAAapG,GAAYxG,EAAEmH,aACnCmD,EAAkBtK,EAAGuC,EAAO,EAAGgE,EAASC,GACxCF,EAAMtG,EAAE0K,OAEJ+B,IAAsBE,IACzBxD,EAAiBsD,GACjBnG,EAAMoG,EAAS,MAGhB1M,EAAI6J,EAAgBzH,EAAMhB,SAAUmB,EAAOgE,GACvCD,IAAQtG,EAAEmK,WACbnK,EAAEmK,SAAW7D,EAEboG,EAAS,MAEVpC,EAAkBtK,EAAGuC,EAAO,EAAGgE,EAASC,GACxCF,EAAMtG,EAAE0K,KAEJgC,GAAUpG,IAAQoG,IACrBA,EAAOvF,WAAa,KACpBI,EAAkBmF,GAAQ,KAIrBpG,EAOR,QAAS6C,GAAiBxG,GACrBR,EAAQ0K,eAAe1K,EAAQ0K,cAAclK,EAEjD,IAAI+H,GAAO/H,EAAU+H,IAErB/H,GAAU6H,UAAW,EAEjB7H,EAAUmK,sBAAsBnK,EAAUmK,uBAE9CnK,EAAU+H,KAAO,IAGjB,IAAIqC,GAAQpK,EAAUwE,UAClB4F,GACH5D,EAAiB4D,GACPrC,IACNA,EAAA,eAAyBA,EAAA,cAAsBtB,KAAKsB,EAAA,cAAsBtB,IAAI,MAElFzG,EAAUwH,SAAWO,EAErBxG,EAAWwG,GACXhB,EAAiB/G,GAEjB0G,EAAeqB,IAGZ/H,EAAU8H,OAAO9H,EAAU8H,MAAM,MActC,QAASR,GAAU1H,EAAOgE,GACzBT,KAAKlD,QAAS,EAKdkD,KAAKS,QAAUA,EAKfT,KAAKvD,MAAQA,EAKbuD,KAAKuE,MAAQvE,KAAKuE,UA8DnB,QAASL,GAAO5H,EAAOqE,EAAQuG,GAC7B,MAAO3G,GAAK2G,EAAO5K,MAAW,EAAOqE,GAAQ,GFt5B/CpG,OAAOC,eAAeZ,EAAS,cAC9B6E,OAAO,GAGR,IAAIG,GAA4B,kBAAXuI,SAAoD,gBAApBA,QAAOC,SAAwB,SAAU5K,GAAO,aAAcA,IAAS,SAAUA,GAAO,MAAOA,IAAyB,kBAAX2K,SAAyB3K,EAAIqH,cAAgBsD,QAAU3K,IAAQ2K,OAAOnM,UAAY,eAAkBwB,IErElQH,KAwBAN,KAEAH,KAmGAqB,EAA0B,kBAAXoK,SAAwBA,QAAQC,UAAUC,KAAKC,KAAKH,QAAQC,WAAaG,WAaxF5I,EAAqB,yDAIrB9B,KAkKAqD,KAGAS,EAAY,EAGZC,GAAY,EAGZvD,GAAY,EA6RZuG,IAqUJvH,GAAO4H,EAAUnJ,WAehB0M,SAAU,SAAkBnD,EAAOoD,GAClC,GAAIxM,GAAI6E,KAAKuE,KACRvE,MAAKuF,YAAWvF,KAAKuF,UAAYhJ,KAAWpB,IACjDoB,EAAOpB,EAAoB,kBAAVoJ,GAAuBA,EAAMpJ,EAAG6E,KAAKvD,OAAS8H,GAC3DoD,IAAW3H,KAAK0G,iBAAmB1G,KAAK0G,sBAAwB1K,KAAK2L,GACzE/K,EAAcoD,OAQf4H,YAAa,SAAqBD,GAC7BA,IAAW3H,KAAK0G,iBAAmB1G,KAAK0G,sBAAwB1K,KAAK2L,GACzEvK,EAAgB4C,KAAM,IAWvBkE,OAAQ,cAsBT,IAAI2D,IACHxM,EAAGA,EACH8C,cAAe9C,EACfqB,aAAcA,EACdyH,UAAWA,EACXD,OAAQA,EACRhH,SAAUA,EACVb,QAASA,EF+EVzC,GE5ESyB,IF6ETzB,EE7EiBuE,cAAL9C,EF8EZzB,EE9EgC8C,eF+EhC9C,EE/E8CuK,YFgF9CvK,EEhFyDsK,SFiFzDtK,EEjFiEsD,WFkFjEtD,EElF2EyC,UFmF3EzC,EAAQkO,QElFOD,GFuFT,SAAUhO,EAAQD,EAASH,GAEjC,YAGA,IGxkCIsO,GHwkCAnJ,EAA4B,kBAAXuI,SAAoD,gBAApBA,QAAOC,SAAwB,SAAU5K,GAAO,aAAcA,IAAS,SAAUA,GAAO,MAAOA,IAAyB,kBAAX2K,SAAyB3K,EAAIqH,cAAgBsD,QAAU3K,IAAQ2K,OAAOnM,UAAY,eAAkBwB,GGrkCtQuL,GAAK,WACJ,MAAO/H,QAGR,KAEC+H,EAAIA,GAAKC,SAAS,mBAAoB,EAAGC,MAAM,QAC9C,MAAMlI,GAEc,YAAlB,mBAAOmI,QAAP,YAAAtJ,EAAOsJ,WACTH,EAAIG,QAONrO,EAAOD,QAAUmO,GH6kCX,SAAUlO,EAAQD,EAASH,GAEjC,YIjmCO,SAAS0O,GAAKC,GAAwC,OAAAC,GAAAxM,UAAAC,OAAlBwM,EAAkBC,MAAAF,EAAA,EAAAA,EAAA,KAAAG,EAAA,EAAAA,EAAAH,EAAAG,IAAlBF,EAAkBE,EAAA,GAAA3M,UAAA2M,EAC3D,QAAQJ,GAAWK,OAAOH,EAAUI,OAAOC,SAASC,IAAI,SAAAC,GAAA,MAAeT,GAAf,KAA6BS,KAAaC,KAAK,KJmmCzGvO,OAAOC,eAAeZ,EAAS,cAC7B6E,OAAO,IAET7E,EIvmCgBuO,OJonCV,SAAUtO,EAAQD,EAASH,GAEjC,YAcA,SAASsP,GAAgBC,EAAUC,GAAe,KAAMD,YAAoBC,IAAgB,KAAM,IAAIC,WAAU,qCAEhH,QAASC,GAA2BC,EAAMpP,GAAQ,IAAKoP,EAAQ,KAAM,IAAIC,gBAAe,4DAAgE,QAAOrP,GAAyB,gBAATA,IAAqC,kBAATA,GAA8BoP,EAAPpP,EAElO,QAASsP,GAAUC,EAAUC,GAAc,GAA0B,kBAAfA,IAA4C,OAAfA,EAAuB,KAAM,IAAIN,WAAU,iEAAoEM,GAAeD,GAASvO,UAAYT,OAAOkP,OAAOD,GAAcA,EAAWxO,WAAa6I,aAAepF,MAAO8K,EAAU7O,YAAY,EAAOgP,UAAU,EAAMjP,cAAc,KAAe+O,IAAYjP,OAAOoP,eAAiBpP,OAAOoP,eAAeJ,EAAUC,GAAcD,EAASK,UAAYJ,GK9mCje,QAASK,GAASC,GAChB,MAAO,UAACC,GAA0B,GAC1BC,GAD0B,SAAAC,GAAA,QAAAD,KAAA,GAAAE,GAAAC,EAAAC,EAAAC,CAAAtB,GAAA/I,KAAAgK,EAAA,QAAA3B,GAAAxM,UAAAC,OAAAwO,EAAA/B,MAAAF,GAAAG,EAAA,EAAAA,EAAAH,EAAAG,IAAA8B,EAAA9B,GAAA3M,UAAA2M,EAAA,OAAA2B,GAAAC,EAAAjB,EAAAnJ,MAAAkK,EAAAF,EAAAJ,WAAArP,OAAAgQ,eAAAP,IAAAhQ,KAAAwQ,MAAAN,GAAAlK,MAAAyI,OAAA6B,KAAAF,EAE9BN,gBAAkB,SAACrF,GACjB,MAAOqF,GAAkBA,EAAgBrF,GAAQA,GAHrB4F,EAAAF,EAAAhB,EAAAiB,EAAAC,GAAA,MAAAf,GAAAU,EAAAC,GAAAQ,EAAAT,IAAA5N,IAAA,SAAAqC,MAAA,WAM5B,OAAO,EAAAiM,EAAArP,GAAE0O,EAAFY,KACF3K,KAAK8J,iBACNc,gBAAiB5K,KAAKS,QAAQmK,gBAC9BC,YAAa7K,KAAKS,QAAQoK,cAEzB7K,KAAKvD,YAXkBuN,GAAAU,EAAAvG,UAgBhC,OADA6F,GAAUc,YAAV,YAAmCf,EAAiBe,aAAef,EAAiB3P,MAAQ,aAA5F,IACO4P,GL8kCXzP,OAAOC,eAAeZ,EAAS,cAC7B6E,OAAO,IAET7E,EAAQiQ,QAAUjQ,EAAQmR,aAAW7O,EAErC,IAAIyO,GAAWpQ,OAAOyQ,QAAU,SAAUC,GAAU,IAAK,GAAInR,GAAI,EAAGA,EAAI+B,UAAUC,OAAQhC,IAAK,CAAE,GAAIoR,GAASrP,UAAU/B,EAAI,KAAK,GAAIsC,KAAO8O,GAAc3Q,OAAOS,UAAUC,eAAejB,KAAKkR,EAAQ9O,KAAQ6O,EAAO7O,GAAO8O,EAAO9O,IAAY,MAAO6O,IAEnPR,EAAe,WAAc,QAASU,GAAiBF,EAAQxO,GAAS,IAAK,GAAI3C,GAAI,EAAGA,EAAI2C,EAAMX,OAAQhC,IAAK,CAAE,GAAIsR,GAAa3O,EAAM3C,EAAIsR,GAAW1Q,WAAa0Q,EAAW1Q,aAAc,EAAO0Q,EAAW3Q,cAAe,EAAU,SAAW2Q,KAAYA,EAAW1B,UAAW,GAAMnP,OAAOC,eAAeyQ,EAAQG,EAAWhP,IAAKgP,IAAiB,MAAO,UAAUnC,EAAaoC,EAAYC,GAAiJ,MAA9HD,IAAYF,EAAiBlC,EAAYjO,UAAWqQ,GAAiBC,GAAaH,EAAiBlC,EAAaqC,GAAqBrC,MKjoChiByB,EAAAjR,EAAA,GAWMsR,ELioCS,SAAUQ,GAGvB,QAASR,KAGP,MAFAhC,GAAgB/I,KAAM+K,GAEf5B,EAA2BnJ,MAAO+K,EAASnB,WAAarP,OAAOgQ,eAAeQ,IAAWP,MAAMxK,KAAMnE,YAkB9G,MAvBAyN,GAAUyB,EAAUQ,GAQpBd,EAAaM,IACX3O,IAAK,kBACLqC,MAAO,WK1oCP,OACEmM,gBAAiB5K,KAAKvD,MAAMmO,gBAC5BC,YAAa7K,KAAKvD,MAAMoO,gBL+oC1BzO,IAAK,SACLqC,MAAO,WK5oCP,MAAOuB,MAAKvD,MAAMd,SAAS,OLipCtBoP,GACPL,EAAQvG,UK9oCV4G,GAASD,YAAc,WLyrCvBlR,EKhqCSmR,WLiqCTnR,EKjqCmBiQ,WLqqCb,SAAUhQ,EAAQD,GMrtCxBC,EAAAD,SAAkB4R,KAAA,6BAAAC,IAAA,4BAAAC,cAAA,oCAAAC,aAAA,mCAAAC,mBAAA,2CN4tCZ,SAAU/R,EAAQD,EAASH,GAEjCA,EAAoB,GACpBI,EAAOD,QAAUH,EAAoB,KAK/B,SAAUI,EAAQD,EAASH,GAEjC,YOtuCAA,GAAA,GACAA,EAAA,KP8uCM,SAAUI,EAAQD,EAASH,GAEjC,YQlvCA,IAAAoS,GAAApS,EAAA,GRuvCIqS,EAEJ,SAAgCtP,GAAO,MAAOA,IAAOA,EAAI3B,WAAa2B,GAAQsL,QAAStL,IAFlDqP,GQrvCjCE,EAAU,WAIZ,GAAoB,mBAAT3C,MACT,MAAOA,KAET,IAAsB,mBAAXlB,QACT,MAAOA,OAET,QAAsB,KAAX6D,EACT,MAAOA,EAET,MAAM,IAAIC,OAAM,oCAGbD,GAAO1E,UACV0E,EAAO1E,QAAPyE,EAAAhE,UR8vCI,SAAUjO,EAAQD,EAASH,GAEjC,cAC4B,SAASwS,GShxCrC,QAASC,MAGT,QAAS1E,GAAK2E,EAAIC,GAChB,MAAO,YACLD,EAAG3B,MAAM4B,EAASvQ,YAItB,QAASwL,GAAQ8E,GACf,KAAMnM,eAAgBqH,IACpB,KAAM,IAAI6B,WAAU,uCACtB,IAAkB,kBAAPiD,GAAmB,KAAM,IAAIjD,WAAU,iBAClDlJ,MAAKqM,OAAS,EACdrM,KAAKsM,UAAW,EAChBtM,KAAKuM,WAASrQ,GACd8D,KAAKwM,cAELC,EAAUN,EAAInM,MAGhB,QAAS0M,GAAOtD,EAAMuD,GACpB,KAAuB,IAAhBvD,EAAKiD,QACVjD,EAAOA,EAAKmD,MAEd,IAAoB,IAAhBnD,EAAKiD,OAEP,WADAjD,GAAKoD,WAAWxQ,KAAK2Q,EAGvBvD,GAAKkD,UAAW,EAChBjF,EAAQuF,aAAa,WACnB,GAAIC,GAAqB,IAAhBzD,EAAKiD,OAAeM,EAASG,YAAcH,EAASI,UAC7D,IAAW,OAAPF,EAEF,YADiB,IAAhBzD,EAAKiD,OAAe/E,EAAU0F,GAAQL,EAASM,QAAS7D,EAAKmD,OAGhE,IAAIvL,EACJ,KACEA,EAAM6L,EAAGzD,EAAKmD,QACd,MAAOxM,GAEP,WADAiN,GAAOL,EAASM,QAASlN,GAG3BuH,EAAQqF,EAASM,QAASjM,KAI9B,QAASsG,GAAQ8B,EAAM8D,GACrB,IAEE,GAAIA,IAAa9D,EACf,KAAM,IAAIF,WAAU,4CACtB,IACEgE,IACqB,gBAApB,KAAOA,EAAP,YAAAtO,EAAOsO,KAA6C,kBAAbA,IACxC,CACA,GAAI3F,GAAO2F,EAAS3F,IACpB,IAAI2F,YAAoB7F,GAItB,MAHA+B,GAAKiD,OAAS,EACdjD,EAAKmD,OAASW,MACdC,GAAO/D,EAEF,IAAoB,kBAAT7B,GAEhB,WADAkF,GAAUjF,EAAKD,EAAM2F,GAAW9D,GAIpCA,EAAKiD,OAAS,EACdjD,EAAKmD,OAASW,EACdC,EAAO/D,GACP,MAAOrJ,GACPiN,EAAO5D,EAAMrJ,IAIjB,QAASiN,GAAO5D,EAAM8D,GACpB9D,EAAKiD,OAAS,EACdjD,EAAKmD,OAASW,EACdC,EAAO/D,GAGT,QAAS+D,GAAO/D,GACM,IAAhBA,EAAKiD,QAA2C,IAA3BjD,EAAKoD,WAAW1Q,QACvCuL,EAAQuF,aAAa,WACdxD,EAAKkD,UACRjF,EAAQ+F,sBAAsBhE,EAAKmD,SAKzC,KAAK,GAAIzS,GAAI,EAAG+I,EAAMuG,EAAKoD,WAAW1Q,OAAQhC,EAAI+I,EAAK/I,IACrD4S,EAAOtD,EAAMA,EAAKoD,WAAW1S,GAE/BsP,GAAKoD,WAAa,KAGpB,QAASa,GAAQP,EAAaC,EAAYE,GACxCjN,KAAK8M,YAAqC,kBAAhBA,GAA6BA,EAAc,KACrE9M,KAAK+M,WAAmC,kBAAfA,GAA4BA,EAAa,KAClE/M,KAAKiN,QAAUA,EASjB,QAASR,GAAUN,EAAI/C,GACrB,GAAIkE,IAAO,CACX,KACEnB,EACE,SAAS1N,GACH6O,IACJA,GAAO,EACPhG,EAAQ8B,EAAM3K,KAEhB,SAAS8O,GACHD,IACJA,GAAO,EACPN,EAAO5D,EAAMmE,MAGjB,MAAOC,GACP,GAAIF,EAAM,MACVA,IAAO,EACPN,EAAO5D,EAAMoE,ITopCjBjT,OAAOC,eAAeZ,EAAS,cAC7B6E,OAAO,GAGT,IAAIG,GAA4B,kBAAXuI,SAAoD,gBAApBA,QAAOC,SAAwB,SAAU5K,GAAO,aAAcA,IAAS,SAAUA,GAAO,MAAOA,IAAyB,kBAAX2K,SAAyB3K,EAAIqH,cAAgBsD,QAAU3K,IAAQ2K,OAAOnM,UAAY,eAAkBwB,ISxxClQiR,EAAiBhG,UAoIrBJ,GAAQrM,UAAR,MAA6B,SAAS+R,GACpC,MAAO/M,MAAKuH,KAAK,KAAMwF,IAGzB1F,EAAQrM,UAAUuM,KAAO,SAASuF,EAAaC,GAC7C,GAAIW,GAAO,GAAI1N,MAAK6D,YAAYqI,EAGhC,OADAQ,GAAO1M,KAAM,GAAIqN,GAAQP,EAAaC,EAAYW,IAC3CA,GAGTrG,EAAQrM,UAAR,QAA+B,SAAS2M,GACtC,GAAI9D,GAAc7D,KAAK6D,WACvB,OAAO7D,MAAKuH,KACV,SAAS9I,GACP,MAAOoF,GAAYyD,QAAQK,KAAYJ,KAAK,WAC1C,MAAO9I,MAGX,SAAS8O,GACP,MAAO1J,GAAYyD,QAAQK,KAAYJ,KAAK,WAC1C,MAAO1D,GAAYmJ,OAAOO,QAMlClG,EAAQsG,IAAM,SAASC,GACrB,MAAO,IAAIvG,GAAQ,SAASC,EAAS0F,GAOnC,QAASa,GAAI/T,EAAGgU,GACd,IACE,GAAIA,IAAuB,gBAAf,KAAOA,EAAP,YAAAlP,EAAOkP,KAAmC,kBAARA,IAAqB,CACjE,GAAIvG,GAAOuG,EAAIvG,IACf,IAAoB,kBAATA,GAQT,WAPAA,GAAKvN,KACH8T,EACA,SAASA,GACPD,EAAI/T,EAAGgU,IAETd,GAKN1C,EAAKxQ,GAAKgU,EACU,KAAdC,GACJzG,EAAQgD,GAEV,MAAOkD,GACPR,EAAOQ,IA1BX,IAAKI,OAA6B,KAAfA,EAAI9R,OACrB,KAAM,IAAIoN,WAAU,+BACtB,IAAIoB,GAAO/B,MAAMvN,UAAU2B,MAAM3C,KAAK4T,EACtC,IAAoB,IAAhBtD,EAAKxO,OAAc,MAAOwL,MA2B9B,KAAK,GA1BDyG,GAAYzD,EAAKxO,OA0BZhC,EAAI,EAAGA,EAAIwQ,EAAKxO,OAAQhC,IAC/B+T,EAAI/T,EAAGwQ,EAAKxQ,OAKlBuN,EAAQC,QAAU,SAAS7I,GACzB,MAAIA,IAA0B,gBAAjB,KAAOA,EAAP,YAAAG,EAAOH,KAAsBA,EAAMoF,cAAgBwD,EACvD5I,EAGF,GAAI4I,GAAQ,SAASC,GAC1BA,EAAQ7I,MAIZ4I,EAAQ2F,OAAS,SAASvO,GACxB,MAAO,IAAI4I,GAAQ,SAASC,EAAS0F,GACnCA,EAAOvO,MAIX4I,EAAQ2G,KAAO,SAASC,GACtB,MAAO,IAAI5G,GAAQ,SAASC,EAAS0F,GACnC,IAAK,GAAIlT,GAAI,EAAG+I,EAAMoL,EAAOnS,OAAQhC,EAAI+I,EAAK/I,IAC5CmU,EAAOnU,GAAGyN,KAAKD,EAAS0F,MAM9B3F,EAAQuF,aACmB,kBAAjBX,IACN,SAASE,GACPF,EAAaE,KAEjB,SAASA,GACPsB,EAAetB,EAAI,IAGvB9E,EAAQ+F,sBAAwB,SAA+Bc,GACtC,mBAAZC,UAA2BA,SACpCA,QAAQC,KAAK,wCAAyCF,IT6wC1DtU,EAAQkO,QSzwCOT,IT0wCcrN,KAAKJ,EAASH,EAAoB,GAAGwS,eAI5D,SAAUpS,EAAQD,EAASH,GAEjC,cAC4B,SAASsS,GU/+CrC,QAASsC,GAAQC,EAAIC,GACnBvO,KAAKwO,IAAMF,EACXtO,KAAKyO,SAAWF,EAnBlB,GAAI/D,GAAQxC,SAAShN,UAAUwP,KAI/B5Q,GAAQ6N,WAAa,WACnB,MAAO,IAAI4G,GAAQ7D,EAAMxQ,KAAKyN,WAAYS,OAAQrM,WAAY6S,eAEhE9U,EAAQ+U,YAAc,WACpB,MAAO,IAAIN,GAAQ7D,EAAMxQ,KAAK2U,YAAazG,OAAQrM,WAAY+S,gBAEjEhV,EAAQ8U,aACR9U,EAAQgV,cAAgB,SAASC,GAC3BA,GACFA,EAAQC,SAQZT,EAAQrT,UAAU+T,MAAQV,EAAQrT,UAAUsI,IAAM,aAClD+K,EAAQrT,UAAU8T,MAAQ,WACxB9O,KAAKyO,SAASzU,KAAKkO,OAAQlI,KAAKwO,MAIlC5U,EAAQoV,OAAS,SAASC,EAAMC,GAC9BR,aAAaO,EAAKE,gBAClBF,EAAKG,aAAeF,GAGtBtV,EAAQyV,SAAW,SAASJ,GAC1BP,aAAaO,EAAKE,gBAClBF,EAAKG,cAAgB,GAGvBxV,EAAQ0V,aAAe1V,EAAQ2V,OAAS,SAASN,GAC/CP,aAAaO,EAAKE,eAElB,IAAID,GAAQD,EAAKG,YACbF,IAAS,IACXD,EAAKE,eAAiB1H,WAAW,WAC3BwH,EAAKO,YACPP,EAAKO,cACNN,KAKPzV,EAAQ,IAIRG,EAAQqS,aAAgC,mBAAT7C,OAAwBA,KAAK6C,kBAClB,KAAXF,GAA0BA,EAAOE,kBACxC/P,GACxBtC,EAAQ6V,eAAkC,mBAATrG,OAAwBA,KAAKqG,oBAClB,KAAX1D,GAA0BA,EAAO0D,oBACxCvT,KV6/CGlC,KAAKJ,EAASH,EAAoB,KAIzD,SAAUI,EAAQD,EAASH,GAEjC,cAC4B,SAASsS,EAAQ2D,IW/jD5C,SAAU3D,EAAQ7P,GAaf,QAAS+P,GAAatE,GAEI,kBAAbA,KACTA,EAAW,GAAIK,UAAS,GAAKL,GAI/B,KAAK,GADD2C,GAAO,GAAI/B,OAAM1M,UAAUC,OAAS,GAC/BhC,EAAI,EAAGA,EAAIwQ,EAAKxO,OAAQhC,IAC7BwQ,EAAKxQ,GAAK+B,UAAU/B,EAAI,EAG5B,IAAI6V,IAAShI,SAAUA,EAAU2C,KAAMA,EAGvC,OAFAsF,GAAcC,GAAcF,EAC5BG,EAAkBD,GACXA,IAGT,QAASJ,GAAe/C,SACbkD,GAAclD,GAGzB,QAASqD,GAAIJ,GACT,GAAIhI,GAAWgI,EAAKhI,SAChB2C,EAAOqF,EAAKrF,IAChB,QAAQA,EAAKxO,QACb,IAAK,GACD6L,GACA,MACJ,KAAK,GACDA,EAAS2C,EAAK,GACd,MACJ,KAAK,GACD3C,EAAS2C,EAAK,GAAIA,EAAK,GACvB,MACJ,KAAK,GACD3C,EAAS2C,EAAK,GAAIA,EAAK,GAAIA,EAAK,GAChC,MACJ,SACI3C,EAAS6C,MAAMtO,EAAWoO,IAKlC,QAAS0F,GAAatD,GAGlB,GAAIuD,EAGAxI,WAAWuI,EAAc,EAAGtD,OACzB,CACH,GAAIiD,GAAOC,EAAclD,EACzB,IAAIiD,EAAM,CACNM,GAAwB,CACxB,KACIF,EAAIJ,GADR,QAGIF,EAAe/C,GACfuD,GAAwB,KApExC,IAAIlE,EAAOE,aAAX,CAIA,GAII6D,GAJAD,EAAa,EACbD,KACAK,GAAwB,EACxBC,EAAMnE,EAAO9N,SAoJbkS,EAAW5V,OAAOgQ,gBAAkBhQ,OAAOgQ,eAAewB,EAC9DoE,GAAWA,GAAYA,EAAS1I,WAAa0I,EAAWpE,EAGf,wBAAlCqE,SAASpW,KAAK+R,EAAO2D,SArF5B,WACII,EAAoB,SAASpD,GACzBgD,EAAQW,SAAS,WAAcL,EAAatD,SAIpD,WAGI,GAAIX,EAAOuE,cAAgBvE,EAAOwE,cAAe,CAC7C,GAAIC,IAA4B,EAC5BC,EAAe1E,EAAO2E,SAM1B,OALA3E,GAAO2E,UAAY,WACfF,GAA4B,GAEhCzE,EAAOuE,YAAY,GAAI,KACvBvE,EAAO2E,UAAYD,EACZD,MAIf,WAKI,GAAIG,GAAgB,gBAAkBC,KAAKC,SAAW,IAClDC,EAAkB,SAAS5Q,GACvBA,EAAMgL,SAAWa,GACK,gBAAf7L,GAAM6Q,MACyB,IAAtC7Q,EAAM6Q,KAAKC,QAAQL,IACnBX,GAAc9P,EAAM6Q,KAAKpU,MAAMgU,EAAc7U,SAIjDiQ,GAAO3M,iBACP2M,EAAO3M,iBAAiB,UAAW0R,GAAiB,GAEpD/E,EAAOkF,YAAY,YAAaH,GAGpChB,EAAoB,SAASpD,GACzBX,EAAOuE,YAAYK,EAAgBjE,EAAQ,SAmDxCX,EAAOmF,eA/ClB,WACI,GAAIC,GAAU,GAAID,eAClBC,GAAQC,MAAMV,UAAY,SAASxQ,GAE/B8P,EADa9P,EAAM6Q,OAIvBjB,EAAoB,SAASpD,GACzByE,EAAQE,MAAMf,YAAY5D,OA2CvBwD,GAAO,sBAAwBA,GAAI/R,cAAc,UAvC5D,WACI,GAAImT,GAAOpB,EAAIqB,eACfzB,GAAoB,SAASpD,GAGzB,GAAI8E,GAAStB,EAAI/R,cAAc,SAC/BqT,GAAOC,mBAAqB,WACxBzB,EAAatD,GACb8E,EAAOC,mBAAqB,KAC5BH,EAAKhT,YAAYkT,GACjBA,EAAS,MAEbF,EAAKpQ,YAAYsQ,OAIzB,WACI1B,EAAoB,SAASpD,GACzBjF,WAAWuI,EAAc,EAAGtD,OA8BpCyD,EAASlE,aAAeA,EACxBkE,EAASV,eAAiBA,IACZ,mBAATrG,UAAyC,KAAX2C,MAAP7P,GAAuC6P,EAAS3C,QX8jDnDpP,KAAKJ,EAASH,EAAoB,GAAIA,EAAoB,MAIjF,SAAUI,EAAQD,EAASH,GAEjC,YYlvDA,SAASiY,KACL,KAAM,IAAI1F,OAAM,mCAEpB,QAAS2F,KACL,KAAM,IAAI3F,OAAM,qCAsBpB,QAAS4F,GAAWC,GAChB,GAAIC,IAAqBrK,WAErB,MAAOA,YAAWoK,EAAK,EAG3B,KAAKC,IAAqBJ,IAAqBI,IAAqBrK,WAEhE,MADAqK,GAAmBrK,WACZA,WAAWoK,EAAK,EAE3B,KAEI,MAAOC,GAAiBD,EAAK,GAC/B,MAAM9R,GACJ,IAEI,MAAO+R,GAAiB9X,KAAK,KAAM6X,EAAK,GAC1C,MAAM9R,GAEJ,MAAO+R,GAAiB9X,KAAKgG,KAAM6R,EAAK,KAMpD,QAASE,GAAgBC,GACrB,GAAIC,IAAuBvD,aAEvB,MAAOA,cAAasD,EAGxB,KAAKC,IAAuBN,IAAwBM,IAAuBvD,aAEvE,MADAuD,GAAqBvD,aACdA,aAAasD,EAExB,KAEI,MAAOC,GAAmBD,GAC5B,MAAOjS,GACL,IAEI,MAAOkS,GAAmBjY,KAAK,KAAMgY,GACvC,MAAOjS,GAGL,MAAOkS,GAAmBjY,KAAKgG,KAAMgS,KAYjD,QAASE,KACAC,GAAaC,IAGlBD,GAAW,EACPC,EAAatW,OACbuW,EAAQD,EAAa3J,OAAO4J,GAE5BC,GAAc,EAEdD,EAAMvW,QACNyW,KAIR,QAASA,KACL,IAAIJ,EAAJ,CAGA,GAAItD,GAAU+C,EAAWM,EACzBC,IAAW,CAGX,KADA,GAAItP,GAAMwP,EAAMvW,OACV+G,GAAK,CAGP,IAFAuP,EAAeC,EACfA,OACSC,EAAazP,GACduP,GACAA,EAAaE,GAAYvC,KAGjCuC,IAAc,EACdzP,EAAMwP,EAAMvW,OAEhBsW,EAAe,KACfD,GAAW,EACXJ,EAAgBlD,IAiBpB,QAAS2D,GAAKX,EAAKY,GACfzS,KAAK6R,IAAMA,EACX7R,KAAKyS,MAAQA,EAYjB,QAASvG,MAhKT,GAOI4F,GACAG,EARAvC,EAAU7V,EAAOD,YAgBpB,WACG,IAEQkY,EADsB,kBAAfrK,YACYA,WAEAiK,EAEzB,MAAO3R,GACL+R,EAAmBJ,EAEvB,IAEQO,EADwB,kBAAjBvD,cACcA,aAEAiD,EAE3B,MAAO5R,GACLkS,EAAqBN,KAuD7B,IAEIS,GAFAC,KACAF,GAAW,EAEXG,GAAc,CAyClB5C,GAAQW,SAAW,SAAUwB,GACzB,GAAIvH,GAAO,GAAI/B,OAAM1M,UAAUC,OAAS,EACxC,IAAID,UAAUC,OAAS,EACnB,IAAK,GAAIhC,GAAI,EAAGA,EAAI+B,UAAUC,OAAQhC,IAClCwQ,EAAKxQ,EAAI,GAAK+B,UAAU/B,EAGhCuY,GAAMrW,KAAK,GAAIwW,GAAKX,EAAKvH,IACJ,IAAjB+H,EAAMvW,QAAiBqW,GACvBP,EAAWW,IASnBC,EAAKxX,UAAU+U,IAAM,WACjB/P,KAAK6R,IAAIrH,MAAM,KAAMxK,KAAKyS,QAE9B/C,EAAQgD,MAAQ,UAChBhD,EAAQiD,SAAU,EAClBjD,EAAQkD,OACRlD,EAAQmD,QACRnD,EAAQoD,QAAU,GAClBpD,EAAQqD,YAIRrD,EAAQsD,GAAK9G,EACbwD,EAAQuD,YAAc/G,EACtBwD,EAAQwD,KAAOhH,EACfwD,EAAQyD,IAAMjH,EACdwD,EAAQ0D,eAAiBlH,EACzBwD,EAAQ2D,mBAAqBnH,EAC7BwD,EAAQ4D,KAAOpH,EACfwD,EAAQ6D,gBAAkBrH,EAC1BwD,EAAQ8D,oBAAsBtH,EAE9BwD,EAAQ+D,UAAY,SAAUrZ,GAAQ,UAEtCsV,EAAQgE,QAAU,SAAUtZ,GACxB,KAAM,IAAI4R,OAAM,qCAGpB0D,EAAQiE,IAAM,WAAc,MAAO,KACnCjE,EAAQkE,MAAQ,SAAUC,GACtB,KAAM,IAAI7H,OAAM,mCAEpB0D,EAAQoE,MAAQ,WAAa,MAAO,KZqwD9B,SAAUja,EAAQD,EAASH,GAEjC,car7DC,SAASyO,EAAQjK,GAuClB,QAAS8V,GAA0BC,GACjChU,KAAKiU,KAAOD,EAAMC,KAClBjU,KAAKiL,OAAS+I,EAAM/I,OACpBjL,KAAKkU,WAAaF,EAAME,WACxBlU,KAAKmU,mBAAqBH,EAAMG,mBAChCnU,KAAKoU,iBAAmBJ,EAAMI,kBAAoBC,IAClDrU,KAAKsU,iBAAmBN,EAAMI,gBAG9B,IAAIG,GAAavU,KAAKmU,mBAClBK,EAAaD,EAAWE,MAAQF,EAAWG,OAC3CN,EAAmBpU,KAAKoU,iBACxBO,EAAmBP,EAAiBK,MAAQL,EAAiBM,MAI/D1U,MAAK4U,kBADHJ,EACuBG,EAAmBH,EAGnBxU,KAAKsU,eAAiB,EAAI,EAcvD,QAASO,GAAqBlN,EAAUmN,GAEtC,GAAIzY,GAAUyY,KAEd,IAAuB,kBAAZnN,GACT,KAAM,IAAIqE,OAAM,8BAGlB,IAAI3P,EAAQmP,MAAiC,GAAzBnP,EAAQmP,KAAKuJ,SAC/B,KAAM,IAAI/I,OAAM,0BAIlBhM,MAAKgV,uBAAyBC,EAC1BjV,KAAKgV,uBAAuBxN,KAAKxH,MAAOA,KAAKkV,kBAGjDlV,KAAKmV,UAAYxN,EACjB3H,KAAKoV,uBACLpV,KAAKqV,kBACLrV,KAAKsV,kBAAoBtV,KAAKuV,iBAAiBlZ,EAAQmZ,YAGvDxV,KAAKyV,WAAazV,KAAK0V,gBAAgBrZ,EAAQsZ,WAC/C3V,KAAKwL,KAAOnP,EAAQmP,MAAQ,KAC5BxL,KAAKwV,WAAaxV,KAAKsV,kBAAkB1M,IAAI,SAASgN,GACpD,MAAOA,GAAOnX,MAAQmX,EAAOC,OAC5B/M,KAAK,KAwbV,QAASgN,KACP,MAAO5N,GAAO6N,aAAeA,YAAYD,KAAOC,YAAYD,MAY9D,QAASb,GAAS9I,EAAI0C,GACpB,GAAImH,GAAQ,IACZ,OAAO,YACAA,IACHA,EAAQvO,WAAW,WACjB0E,IACA6J,EAAQ,MACPnH,KAcT,QAASoH,GAAS3Y,EAAM4C,EAAOiM,EAAI+J,GACG,kBAAzB5Y,GAAK8B,iBACd9B,EAAK8B,iBAAiBc,EAAOiM,EAAI+J,IAAkB,GAEjB,kBAApB5Y,GAAK2T,aACnB3T,EAAK2T,YAAY,KAAO/Q,EAAOiM,GAanC,QAASgK,GAAY7Y,EAAM4C,EAAOiM,EAAI+J,GACG,kBAA5B5Y,GAAKgC,oBACdhC,EAAKgC,oBAAoBY,EAAOiM,EAAI+J,IAAkB,GAEnB,kBAArB5Y,GAAK8Y,cACnB9Y,EAAK8Y,aAAa,KAAOlW,EAAOiM,GAYpC,QAASkK,GAAwBC,EAAOC,GACtC,GAAIC,GAAM5F,KAAK6F,IAAIH,EAAME,IAAKD,EAAMC,KAChCE,EAAS9F,KAAKhO,IAAI0T,EAAMI,OAAQH,EAAMG,QACtCC,EAAO/F,KAAK6F,IAAIH,EAAMK,KAAMJ,EAAMI,MAClCC,EAAQhG,KAAKhO,IAAI0T,EAAMM,MAAOL,EAAMK,OACpCnC,EAAQmC,EAAQD,EAChBjC,EAASgC,EAASF,CAEtB,OAAQ/B,IAAS,GAAKC,GAAU,IAC9B8B,IAAKA,EACLE,OAAQA,EACRC,KAAMA,EACNC,MAAOA,EACPnC,MAAOA,EACPC,OAAQA,GAUZ,QAASmC,GAAsBC,GAC7B,GAAIC,EAEJ,KACEA,EAAOD,EAAGD,wBACV,MAAO3I,IAKT,MAAK6I,IAGCA,EAAKtC,OAASsC,EAAKrC,SACvBqC,GACEP,IAAKO,EAAKP,IACVI,MAAOG,EAAKH,MACZF,OAAQK,EAAKL,OACbC,KAAMI,EAAKJ,KACXlC,MAAOsC,EAAKH,MAAQG,EAAKJ,KACzBjC,OAAQqC,EAAKL,OAASK,EAAKP,MAGxBO,GAbW1C,IAsBpB,QAASA,KACP,OACEmC,IAAK,EACLE,OAAQ,EACRC,KAAM,EACNC,MAAO,EACPnC,MAAO,EACPC,OAAQ,GAWZ,QAASsC,GAAarW,EAAQlF,GAE5B,IADA,GAAI6B,GAAO7B,EACJ6B,GAAM,CACX,GAAIA,GAAQqD,EAAQ,OAAO,CAE3BrD,GAAO2Z,EAAc3Z,GAEvB,OAAO,EAUT,QAAS2Z,GAAc3Z,GACrB,GAAIqD,GAASrD,EAAKe,UAElB,OAAIsC,IAA6B,IAAnBA,EAAOoU,UAAkBpU,EAAOuW,KAErCvW,EAAOuW,KAETvW,EA5rBT,GAAI,wBAA0BuH,IAC1B,6BAA+BA,IAC/B,qBAAuBA,GAAO6L,0BAA0B/Y,UAY1D,YARM,kBAAoBkN,GAAO6L,0BAA0B/Y,WACzDT,OAAOC,eAAe0N,EAAO6L,0BAA0B/Y,UACrD,kBACAL,IAAK,WACH,MAAOqF,MAAK4U,kBAAoB,KAcxC,IAAIuC,KA6EJtC,GAAqB7Z,UAAUka,iBAAmB,IAQlDL,EAAqB7Z,UAAUoc,cAAgB,KAM/CvC,EAAqB7Z,UAAUqc,uBAAwB,EAQvDxC,EAAqB7Z,UAAUsc,QAAU,SAASrM,GAKhD,IAJ8BjL,KAAKoV,oBAAoBmC,KAAK,SAAStI,GACnE,MAAOA,GAAKuI,SAAWvM,IAGzB,CAIA,IAAMA,GAA6B,GAAnBA,EAAO8J,SACrB,KAAM,IAAI/I,OAAM,4BAGlBhM,MAAKyX,oBACLzX,KAAKoV,oBAAoBpZ,MAAMwb,QAASvM,EAAQ+I,MAAO,OACvDhU,KAAK0X,wBACL1X,KAAKgV,2BAQPH,EAAqB7Z,UAAU2c,UAAY,SAAS1M,GAClDjL,KAAKoV,oBACDpV,KAAKoV,oBAAoB1M,OAAO,SAASuG,GAE3C,MAAOA,GAAKuI,SAAWvM,IAEpBjL,KAAKoV,oBAAoBtZ,SAC5BkE,KAAK4X,0BACL5X,KAAK6X,wBAQThD,EAAqB7Z,UAAU8c,WAAa,WAC1C9X,KAAKoV,uBACLpV,KAAK4X,0BACL5X,KAAK6X,uBAUPhD,EAAqB7Z,UAAU+c,YAAc,WAC3C,GAAIC,GAAUhY,KAAKqV,eAAe1Y,OAElC,OADAqD,MAAKqV,kBACE2C,GAaTnD,EAAqB7Z,UAAU0a,gBAAkB,SAASuC,GACxD,GAAItC,GAAYsC,IAAkB,EAGlC,OAFK1P,OAAM2P,QAAQvC,KAAYA,GAAaA,IAErCA,EAAUwC,OAAOzP,OAAO,SAASpC,EAAGxM,EAAGiI,GAC5C,GAAgB,gBAALuE,IAAiB8R,MAAM9R,IAAMA,EAAI,GAAKA,EAAI,EACnD,KAAM,IAAI0F,OAAM,yDAElB,OAAO1F,KAAMvE,EAAEjI,EAAI,MAgBvB+a,EAAqB7Z,UAAUua,iBAAmB,SAAS8C,GACzD,GAAIC,GAAeD,GAAkB,MACjCE,EAAUD,EAAaE,MAAM,OAAO5P,IAAI,SAASgN,GACnD,GAAI6C,GAAQ,wBAAwBC,KAAK9C,EACzC,KAAK6C,EACH,KAAM,IAAIzM,OAAM,oDAElB,QAAQvN,MAAOka,WAAWF,EAAM,IAAK5C,KAAM4C,EAAM,KAQnD,OAJAF,GAAQ,GAAKA,EAAQ,IAAMA,EAAQ,GACnCA,EAAQ,GAAKA,EAAQ,IAAMA,EAAQ,GACnCA,EAAQ,GAAKA,EAAQ,IAAMA,EAAQ,GAE5BA,GAST1D,EAAqB7Z,UAAU0c,sBAAwB,WAChD1X,KAAK4Y,2BACR5Y,KAAK4Y,0BAA2B,EAI5B5Y,KAAKoX,cACPpX,KAAK6Y,oBAAsBlK,YACvB3O,KAAKgV,uBAAwBhV,KAAKoX,gBAGtCnB,EAAS/N,EAAQ,SAAUlI,KAAKgV,wBAAwB,GACxDiB,EAAShY,EAAU,SAAU+B,KAAKgV,wBAAwB,GAEtDhV,KAAKqX,uBAAyB,oBAAsBnP,KACtDlI,KAAK8Y,aAAe,GAAIC,kBAAiB/Y,KAAKgV,wBAC9ChV,KAAK8Y,aAAaxB,QAAQrZ,GACxB1C,YAAY,EACZyd,WAAW,EACXC,eAAe,EACfC,SAAS,QAYnBrE,EAAqB7Z,UAAU4c,wBAA0B,WACnD5X,KAAK4Y,2BACP5Y,KAAK4Y,0BAA2B,EAEhChK,cAAc5O,KAAK6Y,qBACnB7Y,KAAK6Y,oBAAsB,KAE3B1C,EAAYjO,EAAQ,SAAUlI,KAAKgV,wBAAwB,GAC3DmB,EAAYlY,EAAU,SAAU+B,KAAKgV,wBAAwB,GAEzDhV,KAAK8Y,eACP9Y,KAAK8Y,aAAahB,aAClB9X,KAAK8Y,aAAe,QAY1BjE,EAAqB7Z,UAAUga,uBAAyB,WACtD,GAAImE,GAAcnZ,KAAKoZ,eACnBC,EAAWF,EAAcnZ,KAAKsZ,eAAiBjF,GAEnDrU,MAAKoV,oBAAoBmE,QAAQ,SAAStK,GACxC,GAAIhE,GAASgE,EAAKuI,QACdjD,EAAasC,EAAsB5L,GACnCuO,EAAqBxZ,KAAKyZ,oBAAoBxO,GAC9CyO,EAAWzK,EAAK+E,MAChBI,EAAmB+E,GAAeK,GAClCxZ,KAAK2Z,kCAAkC1O,EAAQoO,GAE/CO,EAAW3K,EAAK+E,MAAQ,GAAID,IAC9BE,KAAM6B,IACN7K,OAAQA,EACRkJ,mBAAoBI,EACpBL,WAAYmF,EACZjF,iBAAkBA,GAGfsF,GAEMP,GAAeK,EAGpBxZ,KAAK6Z,qBAAqBH,EAAUE,IACtC5Z,KAAKqV,eAAerZ,KAAK4d,GAMvBF,GAAYA,EAASpF,gBACvBtU,KAAKqV,eAAerZ,KAAK4d,GAZ3B5Z,KAAKqV,eAAerZ,KAAK4d,IAe1B5Z,MAECA,KAAKqV,eAAevZ,QACtBkE,KAAKmV,UAAUnV,KAAK+X,cAAe/X,OAiBvC6U,EAAqB7Z,UAAU2e,kCAC3B,SAAS1O,EAAQoO,GAGnB,GAA+C,QAA3CnR,EAAO4R,iBAAiB7O,GAAQ8O,QAApC,CAOA,IALA,GAAIxF,GAAasC,EAAsB5L,GACnCmJ,EAAmBG,EACnB5T,EAASsW,EAAchM,GACvB+O,GAAS,GAELA,GAAQ,CACd,GAAIC,GAAa,KACbC,EAAyC,GAAnBvZ,EAAOoU,SAC7B7M,EAAO4R,iBAAiBnZ,KAG5B,IAAmC,QAA/BuZ,EAAoBH,QAAmB,MAmB3C,IAjBIpZ,GAAUX,KAAKwL,MAAQ7K,GAAU1C,GACnC+b,GAAS,EACTC,EAAaZ,GAMT1Y,GAAU1C,EAASkc,MACnBxZ,GAAU1C,EAASsT,iBACa,WAAhC2I,EAAoBE,WACtBH,EAAapD,EAAsBlW,IAMnCsZ,KACF7F,EAAmBiC,EAAwB4D,EAAY7F,IAEhC,KAEzBzT,GAASsW,EAActW,GAEzB,MAAOyT,KASTS,EAAqB7Z,UAAUse,aAAe,WAC5C,GAAID,EACJ,IAAIrZ,KAAKwL,KACP6N,EAAWxC,EAAsB7W,KAAKwL,UACjC,CAEL,GAAI8F,GAAOrT,EAASsT,gBAChB4I,EAAOlc,EAASkc,IACpBd,IACE7C,IAAK,EACLG,KAAM,EACNC,MAAOtF,EAAK+I,aAAeF,EAAKE,YAChC5F,MAAOnD,EAAK+I,aAAeF,EAAKE,YAChC3D,OAAQpF,EAAKgJ,cAAgBH,EAAKG,aAClC5F,OAAQpD,EAAKgJ,cAAgBH,EAAKG,cAGtC,MAAOta,MAAKua,wBAAwBlB,IAUtCxE,EAAqB7Z,UAAUuf,wBAA0B,SAASxD,GAChE,GAAIwB,GAAUvY,KAAKsV,kBAAkB1M,IAAI,SAASgN,EAAQ9b,GACxD,MAAsB,MAAf8b,EAAOC,KAAeD,EAAOnX,MAChCmX,EAAOnX,OAAS3E,EAAI,EAAIid,EAAKtC,MAAQsC,EAAKrC,QAAU,MAEtD8F,GACFhE,IAAKO,EAAKP,IAAM+B,EAAQ,GACxB3B,MAAOG,EAAKH,MAAQ2B,EAAQ,GAC5B7B,OAAQK,EAAKL,OAAS6B,EAAQ,GAC9B5B,KAAMI,EAAKJ,KAAO4B,EAAQ,GAK5B,OAHAiC,GAAQ/F,MAAQ+F,EAAQ5D,MAAQ4D,EAAQ7D,KACxC6D,EAAQ9F,OAAS8F,EAAQ9D,OAAS8D,EAAQhE,IAEnCgE,GAcT3F,EAAqB7Z,UAAU6e,qBAC3B,SAASH,EAAUE,GAIrB,GAAIa,GAAWf,GAAYA,EAASpF,eAChCoF,EAAS9E,mBAAqB,GAAK,EACnC8F,EAAWd,EAAStF,eACpBsF,EAAShF,mBAAqB,GAAK,CAGvC,IAAI6F,IAAaC,EAEjB,IAAK,GAAI5gB,GAAI,EAAGA,EAAIkG,KAAKyV,WAAW3Z,OAAQhC,IAAK,CAC/C,GAAI6b,GAAY3V,KAAKyV,WAAW3b,EAIhC,IAAI6b,GAAa8E,GAAY9E,GAAa+E,GACtC/E,EAAY8E,GAAa9E,EAAY+E,EACvC,OAAO,IAWb7F,EAAqB7Z,UAAUoe,aAAe,WAC5C,OAAQpZ,KAAKwL,MAAQwL,EAAa/Y,EAAU+B,KAAKwL,OAUnDqJ,EAAqB7Z,UAAUye,oBAAsB,SAASxO,GAC5D,MAAO+L,GAAahX,KAAKwL,MAAQvN,EAAUgN,IAS7C4J,EAAqB7Z,UAAUyc,kBAAoB,WAC7CN,EAASnG,QAAQhR,MAAQ,GAC3BmX,EAASnb,KAAKgE,OASlB6U,EAAqB7Z,UAAU6c,oBAAsB,WACnD,GAAI8C,GAAQxD,EAASnG,QAAQhR,OACf,GAAV2a,GAAaxD,EAAS7S,OAAOqW,EAAO,IAqL1CzS,EAAO2M,qBAAuBA,EAC9B3M,EAAO6L,0BAA4BA,GAEjC7L,OAAQjK,Wbk5DJ,SAAUpE,EAAQD,EAASH,GAEjC,YcxlFA,SAASmhB,KACPC,IAAetB,QAAQ,SAAAzC,GACrBA,EAAGxI,IAAK,EAAAwM,EAAAC,QACR7S,eAA6B4O,EAAGxI,KAAM,CAGtC,IAAM0M,GAAiBC,KAAKC,MAAMpE,EAAGqE,aAAa,yBAC1CC,EAA8BJ,EAA9BI,0BACFC,GAAoB,EAAAC,EAAAC,qBAAoBH,EAC9CC,GAAkBG,gBAGlB,IAAMC,GAAe3E,EAAGqE,aAAa,uBAC/BO,EAAWT,KAAKC,MAAMpE,EAAGqE,aAAa,kBACpCzI,EAA6BgJ,EAA7BhJ,MAAOiJ,EAAsBD,EAAtBC,OAAQC,EAAcF,EAAdE,UAGjBC,GAAyB,EAAAC,EAAAC,+BAC7B3hB,KAAM,KACNqhB,eACArS,MACEkF,GAAIqN,EACJjJ,QACAsJ,cAAeJ,EAAY,GAAIK,MAAKL,GAAa,MAEnDnb,SACE6N,IAAI,EAAA4N,EAAAC,cAAale,SAASme,SAASC,SAIjCzR,EAAkB,SAAC0R,GACvBjB,EAAkBzQ,iBAAkB0R,aAGhCzR,EAAc,SAAC0R,EAAQ9d,GAC3B,GAAM+d,IACJC,SAAU,eACVF,SACAG,MAAO,qBAELje,KACF+d,EAAS/d,MAAQA,GAEnBod,EAAuBc,UAAUH,KAInC,EAAA9R,EAAAxG,SACE,EAAAwG,EAAArP,GAAAuhB,EAAA7R,UAAUH,gBAAiBA,EAAiBC,YAAaA,IACvD,EAAAH,EAAArP,GAAAwhB,EAAAC,IAAS9B,IAEXlE,EAAIA,EAAGlV,cAab,QAASiZ,KACP,OAAO,EAAAkC,EAAAC,iBAAgB/e,SAASgf,uBAATC,EAAA1R,OACpB9C,OAAO,SAAAoO,GAAA,OAAOqG,EAAcrG,KAGjC,QAASqG,GAAerG,GACtB,MAAOA,GAAGxI,IAAMpG,eAA6B4O,EAAGxI,IAnFlD,GAAA8O,GAAA3jB,EAAA,Id0mFI4jB,EAoBJ,SAAgC7gB,GAAO,MAAOA,IAAOA,EAAI3B,WAAa2B,GAAQsL,QAAStL,IApB/C4gB,GczmFxC1S,EAAAjR,EAAA,GACAsjB,EAAAtjB,EAAA,IACAqhB,EAAArhB,EAAA,IACA6hB,EAAA7hB,EAAA,IACAmjB,EAAAnjB,EAAA,GACAojB,EAAApjB,EAAA,IACAyjB,EAAAzjB,EAAA,GACAqiB,EAAAriB,EAAA,IACAyiB,EAAAziB,EAAA,GAEAyO,gBAA+BA,oBA2E/B,EAAAmV,EAAAvV,SAAS8S,IdgoFH,SAAU/gB,EAAQD,EAASH,GAEjC,YAGgC,mBAAX0N,SAAgCA,OAAOC;;;Ce1tF3D,SAAUhN,EAAMkjB,GAEmBzjB,EAAOD,QAAU0jB,KAInD,EAAY,WAEZ,GAAcC,GAAVC,KACAtN,EAAMjS,SACNwf,EAAOvN,EAAIqB,gBAAgBmM,SAE3BC,GAAUF,EAAO,aAAe,iBAAiB3e,KAAKoR,EAAI0N,WAU9D,OAPKD,IACLzN,EAAI9Q,iBALmB,mBAKgBme,EAAW,WAGhD,IAFArN,EAAI5Q,oBANiB,mBAMqBie,GAC1CI,EAAS,EACFJ,EAAWC,EAAIK,SAASN,MAG1B,SAAUpR,GACfwR,EAASlW,WAAW0E,EAAI,GAAKqR,EAAIxhB,KAAKmQ,OfmuFpC,SAAUtS,EAAQD,EAASH,GAEjC,YgB/vFO,SAASujB,GAAiBc,GAC/B,SAAUnhB,MAAM3C,KAAK8jB,GhBiwFvBvjB,OAAOC,eAAeZ,EAAS,cAC7B6E,OAAO,IAET7E,EgBrwFgBojB,mBhB4wFV,SAAUnjB,EAAQD,EAASH,GAEjC,YiB9wFO,SAASshB,KACd,UAAWnK,KAAKC,SAAST,SAAS,IAAI2N,OAAO,EAAG,GjBgxFlDxjB,OAAOC,eAAeZ,EAAS,cAC7B6E,OAAO,IAET7E,EiBpxFgBmhB,QjB2xFV,SAAUlhB,EAAQD,EAASH,GAEjC,YkB1xFO,SAAS8hB,GAAqByC,GACnC,MAAO,IAAAC,GAAAC,mBACL9jB,KAAM,qBACN+jB,IAAK,0BACLC,QAASJ,IlByxFbzjB,OAAOC,eAAeZ,EAAS,cAC7B6E,OAAO,IAET7E,EkBhyFgB2hB,qBAFhB,IAAA0C,GAAAxkB,EAAA,KlBgzFM,SAAUI,EAAQD,EAASH,GAEjC,YACA,IAAI4kB,GAAgCC,EAA8BC,EAE9D3f,EAA4B,kBAAXuI,SAAoD,gBAApBA,QAAOC,SAAwB,SAAU5K,GAAO,aAAcA,IAAS,SAAUA,GAAO,MAAOA,IAAyB,kBAAX2K,SAAyB3K,EAAIqH,cAAgBsD,QAAU3K,IAAQ2K,OAAOnM,UAAY,eAAkBwB,KmBtzFrQ,SAASuD,EAAEnF,GAAG,UAAAgE,EAAiBhF,QAAS,KAAoBC,EAAOe,EAAEhB,IAA+C0kB,GAAQ1kB,GAARykB,EAAA,MAAAniB,MAAAqiB,EAAA,kBAAAF,KAAA7T,MAAA5Q,EAAA0kB,GAAAD,KAAAxkB,EAAAD,QAAA2kB,KAApHriB,EAA+K,SAAS6D,GAAgB,GAAInF,GAAE,WAAW,QAASmF,GAAEA,EAAEnF,GAAG,IAAI,GAAI4jB,GAAE,EAAEA,EAAE5jB,EAAEkB,OAAO0iB,IAAI,CAAC,GAAIlY,GAAE1L,EAAE4jB,EAAGlY,GAAE5L,WAAW4L,EAAE5L,aAAY,EAAG4L,EAAE7L,cAAa,EAAG,SAAU6L,KAAIA,EAAEoD,UAAS,GAAInP,OAAOC,eAAeuF,EAAEuG,EAAElK,IAAIkK,IAAI,MAAO,UAAS1L,EAAE4jB,EAAElY,GAAG,MAAOkY,IAAGze,EAAEnF,EAAEI,UAAUwjB,GAAGlY,GAAGvG,EAAEnF,EAAE0L,GAAG1L,MAAU4jB,EAAE,WAAW,QAASze,MAAK,SAASA,EAAEnF,GAAG,KAAKmF,YAAanF,IAAG,KAAM,IAAIsO,WAAU,sCAAsClJ,KAAKD,GAAGC,KAAKye,YAAY,MAAO7jB,GAAEmF,IAAI3D,IAAI,qBAAqBqC,MAAM,SAASsB,GAAGC,KAAKye,SAASziB,MAAMiY,KAAK,GAAIgI,MAAKK,QAAQvc,OAAO3D,IAAI,0BAA0BqC,MAAM,SAASsB,EAAEnF,GAAG,MAAOoF,MAAKye,SAAS/V,OAAO,SAAS8V,GAAG,MAAOA,GAAElC,UAAUvc,GAAG,GAAIkc,MAAKuC,EAAEvK,KAAKrZ,IAAIkB,OAAO,MAAMiE,KAAKuG,EAAE,WAAW,QAASvG,GAAEA,EAAEnF,GAAG,IAAI,GAAI4jB,GAAE,EAAEA,EAAE5jB,EAAEkB,OAAO0iB,IAAI,CAAC,GAAIlY,GAAE1L,EAAE4jB,EAAGlY,GAAE5L,WAAW4L,EAAE5L,aAAY,EAAG4L,EAAE7L,cAAa,EAAG,SAAU6L,KAAIA,EAAEoD,UAAS,GAAInP,OAAOC,eAAeuF,EAAEuG,EAAElK,IAAIkK,IAAI,MAAO,UAAS1L,EAAE4jB,EAAElY,GAAG,MAAOkY,IAAGze,EAAEnF,EAAEI,UAAUwjB,GAAGlY,GAAGvG,EAAEnF,EAAE0L,GAAG1L,MAAUd,KAAKQ,EAAE,WAAW,QAASyF,GAAEnF,GAAG,GAAI0L,GAAE1L,EAAER,KAAKE,EAAEM,EAAEujB,IAAIhjB,EAAEP,EAAEwjB,OAAOrc,MAAE,KAAS5G,GAAGA,GAAG,SAAS4E,EAAEnF,GAAG,KAAKmF,YAAanF,IAAG,KAAM,IAAIsO,WAAU,sCAAsClJ,KAAKD,GAAGC,KAAK5F,KAAKkM,EAAEtG,KAAKme,IAAI7jB,EAAE0F,KAAK0e,cAAc,GAAIF,GAAExe,KAAKoe,OAAOrc,EAAEjI,EAAEkC,KAAKgE,KAAK5F,MAAM,MAAOkM,GAAEvG,IAAI3D,IAAI,iBAAiBqC,MAAM,WAAW,GAAIsB,GAAEC,IAAKlG,GAAEgC,QAAQ,IAAIoM,OAAO9I,iBAAiB,QAAQ,SAASxE,GAAG,GAAI4jB,GAAE5jB,EAAE0hB,QAAQhW,EAAE1L,EAAE+jB,SAAS7kB,EAAEc,EAAEgkB,OAAOtkB,EAAEM,EAAEikB,MAAM1jB,GAAGmhB,QAAQkC,EAAG,MAAKlY,IAAInL,EAAEgjB,IAAI7X,GAAGxM,EAAE,IAAIqB,EAAE2jB,KAAKhlB,GAAGQ,EAAE,IAAIa,EAAE4jB,OAAOzkB,GAAGyF,EAAE6K,gBAAgBzP,KAAK+M,OAAO9I,iBAAiB,qBAAqB,SAASxE,GAAGmF,EAAE6K,iBAAiB0R,QAAQ,gCAAgC1hB,EAAE2S,eAAenR,IAAI,kBAAkBqC,MAAM,SAASsB,GAAG,GAAInF,GAAE4jB,EAAElY,CAAEtG,MAAKoe,OAAO,mBAAoBjQ,UAASA,QAAQ6Q,IAAI,YAAY/D,KAAKgE,UAAUlf,IAAIC,KAAK0e,cAAcQ,wBAAwBnf,EAAEuc,QAAQ,OAAOtc,KAAK0e,cAAcS,mBAAmBpf,EAAEuc,SAAS1hB,EAAEoF,KAAKme,IAAI,IAAIne,KAAK5F,KAAKokB,EAAEze,GAAGuG,EAAE,GAAI8Y,iBAAgBC,KAAK,OAAOzkB,GAAG0L,EAAEgZ,iBAAiB,eAAe,oBAAoBhZ,EAAEiZ,KAAKtE,KAAKgE,UAAUT,SAASze,IAAKA,GAAEme,kBAAkB5jB,EAAEC,OAAOC,eAAeuF,EAAE,cAActB,OAAM,OnBu3FzqE,SAAU5E,EAAQD,EAASH,GAEjC,YAkCA,SAAS+lB,GAAmB5R,GAAO,GAAIrF,MAAM2P,QAAQtK,GAAM,CAAE,IAAK,GAAI9T,GAAI,EAAG2lB,EAAOlX,MAAMqF,EAAI9R,QAAShC,EAAI8T,EAAI9R,OAAQhC,IAAO2lB,EAAK3lB,GAAK8T,EAAI9T,EAAM,OAAO2lB,GAAe,MAAOlX,OAAMmX,KAAK9R,GAE1L,QAAS7E,GAAgBC,EAAUC,GAAe,KAAMD,YAAoBC,IAAgB,KAAM,IAAIC,WAAU,qCAEhH,QAASC,GAA2BC,EAAMpP,GAAQ,IAAKoP,EAAQ,KAAM,IAAIC,gBAAe,4DAAgE,QAAOrP,GAAyB,gBAATA,IAAqC,kBAATA,GAA8BoP,EAAPpP,EAElO,QAASsP,GAAUC,EAAUC,GAAc,GAA0B,kBAAfA,IAA4C,OAAfA,EAAuB,KAAM,IAAIN,WAAU,iEAAoEM,GAAeD,GAASvO,UAAYT,OAAOkP,OAAOD,GAAcA,EAAWxO,WAAa6I,aAAepF,MAAO8K,EAAU7O,YAAY,EAAOgP,UAAU,EAAMjP,cAAc,KAAe+O,IAAYjP,OAAOoP,eAAiBpP,OAAOoP,eAAeJ,EAAUC,GAAcD,EAASK,UAAYJ,GoBhuFje,QAASmW,GAAsBlL,GAC7B,MAAIA,GAAQ,KAAa,cACrBA,EAAQ,KAAa,QACrBA,EAAQ,IAAY,SACjB,QpBurFTla,OAAOC,eAAeZ,EAAS,cAC7B6E,OAAO,IAET7E,EAAQkjB,QAAM5gB,EAEd,IAAIuO,GAAe,WAAc,QAASU,GAAiBF,EAAQxO,GAAS,IAAK,GAAI3C,GAAI,EAAGA,EAAI2C,EAAMX,OAAQhC,IAAK,CAAE,GAAIsR,GAAa3O,EAAM3C,EAAIsR,GAAW1Q,WAAa0Q,EAAW1Q,aAAc,EAAO0Q,EAAW3Q,cAAe,EAAU,SAAW2Q,KAAYA,EAAW1B,UAAW,GAAMnP,OAAOC,eAAeyQ,EAAQG,EAAWhP,IAAKgP,IAAiB,MAAO,UAAUnC,EAAaoC,EAAYC,GAAiJ,MAA9HD,IAAYF,EAAiBlC,EAAYjO,UAAWqQ,GAAiBC,GAAaH,EAAiBlC,EAAaqC,GAAqBrC,MoB/3FhiByB,EAAAjR,EAAA,GACAmjB,EAAAnjB,EAAA,GACAojB,EAAApjB,EAAA,GpBq4FIyjB,EAgBJ,SAAgC1gB,GAAO,MAAOA,IAAOA,EAAI3B,WAAa2B,GAAQsL,QAAStL,IAhBpDqgB,GoBp4FnC+C,EAAAnmB,EAAA,IACAomB,EAAApmB,EAAA,GAEAqmB,EAAArmB,EAAA,IACAsmB,EAAAtmB,EAAA,IACAumB,EAAAvmB,EAAA,IACAwmB,EAAAxmB,EAAA,IACAymB,EAAAzmB,EAAA,IAGM0mB,EAAgB,EAClBC,EAAgB,EAqBdC,EpBk4Fa,SAAU9U,GAG3B,QAAS8U,KACP,GAAInW,GAEAC,EAAOmW,EAAOjW,CAElBtB,GAAgB/I,KAAMqgB,EAEtB,KAAK,GAAIhY,GAAOxM,UAAUC,OAAQwO,EAAO/B,MAAMF,GAAOG,EAAO,EAAGA,EAAOH,EAAMG,IAC3E8B,EAAK9B,GAAQ3M,UAAU2M,EAGzB,OAAe2B,GAASmW,EAAQnX,EAA2BnJ,MAAOkK,EAAOmW,EAAazW,WAAarP,OAAOgQ,eAAe8V,IAAermB,KAAKwQ,MAAMN,GAAOlK,MAAMyI,OAAO6B,KAAiBgW,EoB/4F1L/b,OACEgc,OAAQ,EACRC,gBAAgB,EAChBC,sBAAsB,EACtBC,cAAe,IACfC,WAAY,QACZlM,MAAO,EACPC,OAAQ,GpBg5FL4L,EoB74FLM,SAAgB,KpB64FYN,EoB54F5BO,SAAgB,KpB44FmCP,EoB34FnDQ,gBAA+B,KpB24FkDR,EoB14FjFS,OAAuB,KpB04F+ET,EoB92FtGU,iBAAmB,WACjB,GAAMC,eACDhjB,SAASijB,iBAAiB,sCAGzBC,EAAYF,EAAcvY,OAAO,SAAAxO,GAAA,MACrCA,GAAEknB,cAAF,IAAoBlE,EAAApV,QAAO2D,OAC3B,EAEE0V,KACFA,EAAUziB,MAAM2iB,QAAU,KAGxBf,EAAKS,QACPT,EAAK5Y,UACH+M,MAAO6L,EAAKS,OAAOO,YACnB5M,OAAQ4L,EAAKS,OAAOQ,gBpB+2FrBjB,EoB/1FLkB,oBAAsB,WAAM,GAClB3W,GAAgByV,EAAK7jB,MAArBoO,YADkB4W,EAEgBvZ,OAAOwZ,WAC/C,oCADejB,EAFSgB,EAElBE,OAGRrB,GAAK5Y,UAAW+Y,yBACZA,IACFH,EAAK5Y,UAAWgZ,cAAe,KAC/B7V,6BpBk2FCyV,EoB91FLsB,gBAAkB,SAACC,GAAQ,GACjBhX,GAAgByV,EAAK7jB,MAArBoO,WACJuV,IAAiBD,GACf0B,GAAO,KACThX,EAAY,MAAOgX,GACnBzB,MpBk2FDE,EoB71FLwB,cAAgB,SAACC,EAAUlB,GAAa,GAAAmB,GACVD,GAAYA,EAAS,KAAO,EAAhDzN,EAD8B0N,EAC9B1N,eACAkM,EAAmBF,EAAK/b,MAAxBic,eACA3V,EAAgByV,EAAK7jB,MAArBoO,WAEJyJ,KAAmBkM,GACrBF,EAAK5Y,UAAW8Y,gBAAgB,IAChC3V,EAAY,cACH2V,GACT3V,EAAYyJ,EAAiB,YAAc,epBk2F1CgM,EoB91FL2B,aAAe,WACR3B,EAAKS,QACVT,EAAK5Y,UAAWiZ,WAAYhB,EAAqBW,EAAKS,OAAOO,gBpBiyFtDjX,EA8DJF,EAAQhB,EAA2BmX,EAAOjW,GA4F/C,MAvKAf,GAAU+W,EAAc9U,GA+ExBd,EAAa4V,IACXjkB,IAAK,oBACLqC,MAAO,WoBp8FkB,GAAA2L,GAAApK,IACzBA,MAAKiiB,eACLjiB,KAAK8gB,iBAAkB,EAAAlB,EAAAsC,UAASliB,KAAKiiB,aAAc,QACnD/Z,OAAO9I,iBAAiB,SAAUY,KAAK8gB,iBAEvC9gB,KAAKwhB,sBAELxhB,KAAK6gB,SAAW,GAAIhM,sBAAqB7U,KAAK8hB,iBAPrB,IAQjBf,GAAW/gB,KAAX+gB,MACJA,KACF/gB,KAAK0H,UAAW+M,MAAOsM,EAAOO,YAAa5M,OAAQqM,EAAOQ,eAC1DvhB,KAAK6gB,SAASvJ,QAAQyJ,IAGxB/gB,KAAK4gB,SAAWjS,YAAY,WAAM,GACxB4R,GAAWnW,EAAK7F,MAAhBgc,MACRnW,GAAK1C,UACH6Y,OAAQA,EAxDmB,IAwDmBnW,EAAK7F,MAAMmc,iBAE1D,IAAO1gB,KAAKuE,MAAMmc,eAEjB1gB,KAAKvD,MAAM0lB,MACbniB,KAAKghB,sBpB48FP5kB,IAAK,uBACLqC,MAAO,WoBn7FPyJ,OAAO5I,oBAAoB,SAAUU,KAAK8gB,iBACtC9gB,KAAK4gB,UACPhS,cAAc5O,KAAK4gB,UAEjB5gB,KAAK6gB,WACP7gB,KAAK6gB,SAAS/I,aACd9X,KAAK6gB,SAAW,SpBw7FlBzkB,IAAK,SACLqC,MAAO,WoB74FC,GAAA2jB,GAAApiB,KAAAqiB,EAC6BriB,KAAKvD,MAAlC4f,EADAgG,EACAhG,KAAMiG,EADND,EACMC,SAAUC,EADhBF,EACgBE,SADhBlW,EASJrM,KAAKuE,MANPgc,EAHMlU,EAGNkU,OACAC,EAJMnU,EAINmU,eACAG,EALMtU,EAKNsU,WACAjM,EANMrI,EAMNqI,OACAD,EAPMpI,EAONoI,MACAgM,EARMpU,EAQNoU,oBAEF,QACE,EAAA/V,EAAArP,GAAA,OACEmnB,OAAO,EAAA3C,EAAA1X,KAAI+U,EAAApV,QAAO2D,IAAKkV,EAAYH,GAAkB,mBACrDld,IAAK,SAAAwT,GACHsL,EAAKrB,OAASjK,KAGhB,EAAApM,EAAArP,GAAA2kB,EAAAyC,IAAA,OACA,EAAA/X,EAAArP,GAAA0kB,EAAA2C,OACEjC,qBAAsBA,EACtBkC,YAAanC,EACb9L,OAAQA,EACRD,MAAOA,EACPmO,YAAa5iB,KAAK4hB,mBAEpB,EAAAlX,EAAArP,GAAA6kB,EAAA2C,SAAA,OACA,EAAAnY,EAAArP,GAAA4kB,EAAA6C,WAAA,OACA,EAAApY,EAAArP,GAAAykB,EAAAiD,SACExC,OAAQA,EACR+B,SAAUA,EACVjG,KAAMA,EACNkG,SAAUA,SpBy5FXlC,GACP3V,EAAQvG,WoBn5FJ2Y,GAAM,EAAAF,EAAA/S,WAAUwW,EpBu5FtBzmB,GoBr5FSkjB,OpBi6FH,SAAUjjB,EAAQD,EAASH,GAEjC,YqBhmGA,SAASyoB,GAAUc,EAAgBC,EAAcC,GAC/C,GAAIrU,SAEJ,OAAO,YACL,GAAMpO,GAAUT,KACVsK,EAAOzO,UAETsnB,EAAQ,WACVtU,EAAU,KACLqU,GAAWF,EAAKxY,MAAM/J,EAAS6J,IAEhC8Y,EAAUF,IAAcrU,CAC1BA,IAASH,aAAaG,GAC1BA,EAAUpH,WAAW0b,EAAOF,GACxBG,GAASJ,EAAKxY,MAAM/J,EAAS6J,IrBqlGrC/P,OAAOC,eAAeZ,EAAS,cAC7B6E,OAAO,IAoBT7E,EqBtmGSsoB,YrB0mGH,SAAUroB,EAAQD,EAASH,GAEjC,YAGAc,QAAOC,eAAeZ,EAAS,cAC7B6E,OAAO,IAET7E,EAAQmpB,YAAU7mB,EsBroGlB,IAAAwO,GAAAjR,EAAA,GACA4pB,EAAA5pB,EAAA,IACAomB,EAAApmB,EAAA,GACAqmB,EAAArmB,EAAA,ItB4oGI6pB,EAEJ,SAAgC9mB,GAAO,MAAOA,IAAOA,EAAI3B,WAAa2B,GAAQsL,QAAStL,IAFhDsjB,EsBnoG1BiD,WAAU,SAAA7Y,GAAiD,GAA9CqW,GAA8CrW,EAA9CqW,OAAQ+B,EAAsCpY,EAAtCoY,SAAUjG,EAA4BnS,EAA5BmS,KAAMkG,EAAsBrY,EAAtBqY,SAC1CgB,EAAkB3S,KAAK4S,KAAc,GAATjD,GAAakD,eAAe,MACxDC,EAAiB9S,KAAK4S,KAAc,GAATjD,GAAakD,eAAe,KAE7D,QACE,EAAA/Y,EAAArP,GAAA,OAAKmnB,MAAOc,EAAAxb,QAAO,cACjB,EAAA4C,EAAArP,GAAA,OAAKmnB,MAAOc,EAAAxb,QAAO,qBACjB,EAAA4C,EAAArP,GAAA,QAAMmnB,MAAM,UAAZ,mDACmD,IAChD7J,WAAW4H,EAAS,KAAMoD,QAAQ,GAFrC,sCAGaJ,EAHb,kBAG6CG,EAH7C,aAKA,EAAAhZ,EAAArP,GAAA,KAAGmnB,MAAOc,EAAAxb,QAAO,uBAAwB8b,eAAA,IACvC,EAAAlZ,EAAArP,GAAA,QAAMmnB,MAAOc,EAAAxb,QAAO,wBAApB,qCAEQ,KACR,EAAA4C,EAAArP,GAAA,QAAMmnB,MAAOc,EAAAxb,QAAO,wBAApB,mBACA,EAAA4C,EAAArP,GAAAgoB,EAAAQ,SACEtD,OAAQ5H,WAAW4H,EAAS,KAAMoD,QAAQ,GAC1CG,UAAW,WAEb,EAAApZ,EAAArP,GAAA,QAAMmnB,MAAOc,EAAAxb,QAAO,uBAApB,mBAEF,EAAA4C,EAAArP,GAAA,KAAGmnB,OAAO,EAAA3C,EAAA1X,KAAImb,EAAAxb,QAAO,uBAAwB,UAAW8b,eAAA,IACtD,EAAAlZ,EAAArP,GAAA,QAAMmnB,MAAOc,EAAAxb,QAAO,wBAApB,iBACiByb,EADjB,WAC0C,MAE1C,EAAA7Y,EAAArP,GAAA,QAAMmnB,MAAOc,EAAAxb,QAAO,wBAApB,SACS4b,EADT,aAIDpB,GACCjG,IACE,EAAA3R,EAAArP,GAAA,KACEmnB,MAAA,cAAqBc,EAAAxb,QAAO,yBAC5BuU,KAAMA,GAELkG,GAAY,8BACb,EAAA7X,EAAArP,GAAA,QAAMuoB,eAAA,IACJ,EAAAlZ,EAAArP,GAAA,OACE0oB,MAAM,6BACNC,QAAQ,YACRvP,MAAM,OAEN,EAAA/J,EAAArP,GAAA,QACE4oB,OAAO,eACPC,KAAK,OACLC,cAAc,QACdhqB,EAAE,kCtB8rGhB,SAAUN,EAAQD,EAASH,GAEjC,YAGAc,QAAOC,eAAeZ,EAAS,cAC7B6E,OAAO,IAET7E,EAAQiqB,YAAU3nB,EuBjwGlB,IAAAwO,GAAAjR,EAAA,GACA4pB,EAAA5pB,EAAA,IvBswGI2qB,EAEJ,SAAgC5nB,GAAO,MAAOA,IAAOA,EAAI3B,WAAa2B,GAAQsL,QAAStL,IAFhD6mB,EuB/vG1BQ,WAAU,SAAA3Z,GAAkC,GAA/BqW,GAA+BrW,EAA/BqW,OAAQuD,EAAuB5Z,EAAvB4Z,UAC1BO,EAAcloB,OAAOokB,GAAQrhB,QAAQ,IAAK,IAChD,QACE,EAAAwL,EAAArP,GAAA,QAAMyE,UAAWskB,EAAAtc,QAAOwc,SACrBD,EAAY7L,MAAM,IAAI5P,IAAI,SAAC2b,EAAGzqB,GAAJ,OACzB,EAAA4Q,EAAArP,GAAA,QAAMmnB,MAAa,MAAN+B,EAAY,GAAKH,EAAAtc,QAAO0c,gBAAiBpoB,IAAKmoB,EAAI,GAAKzqB,GACjEyqB,KAGJT,KvBixGD,SAAUjqB,EAAQD,GwBnyGxBC,EAAAD,SAAkB0qB,QAAA,gCAAAG,aAAA,mCAAAD,gBAAA,0CxB0yGZ,SAAU3qB,EAAQD,GyB1yGxBC,EAAAD,SAAkB8qB,WAAA,iCAAAC,kBAAA,wCAAAC,sBAAA,4CAAAC,8BAAA,oDAAAC,wBAAA,8CAAAC,qBAAA,2CAAAN,aAAA,mCAAAO,sBAAA,8CzBizGZ,SAAUnrB,EAAQD,EAASH,GAEjC,YAsBA,SAASsP,GAAgBC,EAAUC,GAAe,KAAMD,YAAoBC,IAAgB,KAAM,IAAIC,WAAU,qCAEhH,QAASC,GAA2BC,EAAMpP,GAAQ,IAAKoP,EAAQ,KAAM,IAAIC,gBAAe,4DAAgE,QAAOrP,GAAyB,gBAATA,IAAqC,kBAATA,GAA8BoP,EAAPpP,EAElO,QAASsP,GAAUC,EAAUC,GAAc,GAA0B,kBAAfA,IAA4C,OAAfA,EAAuB,KAAM,IAAIN,WAAU,iEAAoEM,GAAeD,GAASvO,UAAYT,OAAOkP,OAAOD,GAAcA,EAAWxO,WAAa6I,aAAepF,MAAO8K,EAAU7O,YAAY,EAAOgP,UAAU,EAAMjP,cAAc,KAAe+O,IAAYjP,OAAOoP,eAAiBpP,OAAOoP,eAAeJ,EAAUC,GAAcD,EAASK,UAAYJ,GAvBjejP,OAAOC,eAAeZ,EAAS,cAC7B6E,OAAO,IAET7E,EAAQ8oB,UAAQxmB,EAEhB,IAAIuO,GAAe,WAAc,QAASU,GAAiBF,EAAQxO,GAAS,IAAK,GAAI3C,GAAI,EAAGA,EAAI2C,EAAMX,OAAQhC,IAAK,CAAE,GAAIsR,GAAa3O,EAAM3C,EAAIsR,GAAW1Q,WAAa0Q,EAAW1Q,aAAc,EAAO0Q,EAAW3Q,cAAe,EAAU,SAAW2Q,KAAYA,EAAW1B,UAAW,GAAMnP,OAAOC,eAAeyQ,EAAQG,EAAWhP,IAAKgP,IAAiB,MAAO,UAAUnC,EAAaoC,EAAYC,GAAiJ,MAA9HD,IAAYF,EAAiBlC,EAAYjO,UAAWqQ,GAAiBC,GAAaH,EAAiBlC,EAAaqC,GAAqBrC,M0B1zGhiByB,EAAAjR,EAAA,GACAwrB,EAAAxrB,EAAA,IACAomB,EAAApmB,EAAA,GACAsmB,EAAAtmB,EAAA,I1Bi0GIyrB,EAEJ,SAAgC1oB,GAAO,MAAOA,IAAOA,EAAI3B,WAAa2B,GAAQsL,QAAStL,IAFlDujB,EAUzBnmB,G0B7zGC8oB,M1B6zGe,SAAUnX,GAGpC,QAASmX,KACP,GAAIxY,GAEAC,EAAOmW,EAAOjW,CAElBtB,GAAgB/I,KAAM0iB,EAEtB,KAAK,GAAIra,GAAOxM,UAAUC,OAAQwO,EAAO/B,MAAMF,GAAOG,EAAO,EAAGA,EAAOH,EAAMG,IAC3E8B,EAAK9B,GAAQ3M,UAAU2M,EAGzB,OAAe2B,GAASmW,EAAQnX,EAA2BnJ,MAAOkK,EAAOwY,EAAM9Y,WAAarP,OAAOgQ,eAAemY,IAAQ1oB,KAAKwQ,MAAMN,GAAOlK,MAAMyI,OAAO6B,KAAiBgW,E0Bz0G5K/b,OACE4gB,YAAY,G1B00GT7E,E0Bx0GLxa,oBAAsB,SAACsf,IAChB9E,EAAK/b,MAAM4gB,YAAcC,EAAUzC,cACtCrC,EAAK5Y,UAAWyd,YAAY,IAC5B7E,EAAK+E,e1B00GJ/E,E0Bt0GL+E,WAAa,WAAM,GAAAjb,GAAAkW,EACTgF,EADSlb,EACTkb,IADSC,EAEsBjF,EAAK7jB,MAApCgY,EAFS8Q,EAET9Q,MAAOC,EAFE6Q,EAEF7Q,OAAQkO,EAFN2C,EAEM3C,aACvB,EAAAqC,EAAAO,OAAMF,GACJ7Q,QACAC,SACAkO,iB1ByzGKvY,EAoBJF,EAAQhB,EAA2BmX,EAAOjW,GA8B/C,MA/DAf,GAAUoZ,EAAOnX,GAoCjBd,EAAaiY,IACXtmB,IAAK,SACLqC,MAAO,W0B90GC,GAAA2jB,GAAApiB,KACAmlB,EAAenlB,KAAKuE,MAApB4gB,UAGR,OAFiCnlB,MAAKvD,MAA9BgkB,sBAIJ,EAAA/V,EAAArP,GAAA,OAAKmnB,MAAO0C,EAAApd,QAAO2d,kBACjB,EAAA/a,EAAArP,GAAA,OAAKmnB,MAAO0C,EAAApd,QAAO,0BACnB,EAAA4C,EAAArP,GAAA,OAAKmnB,MAAO0C,EAAApd,QAAO,4BAMvB,EAAA4C,EAAArP,GAAA,OACEiI,IAAK,SAAAgiB,GAAA,MAAQlD,GAAKkD,IAAMA,GACxB9C,OAAO,EAAA3C,EAAA1X,KAAI+c,EAAApd,QAAO0d,MAAOL,GAAc,gB1Bu1GtCzC,GACPhY,EAAQvG,YAIJ,SAAUtK,EAAQD,EAASH,GAEjC,Y2BpxGA,SAASisB,GACPC,EADFzb,GASE,IAAK,GANH0b,GAKF1b,EALE0b,eACAnR,EAIFvK,EAJEuK,MACAC,EAGFxK,EAHEwK,OACAwP,EAEFha,EAFEga,KAGOpqB,EAAI,EAAGA,EAAI8rB,EAAgB9rB,GAAK,GADzC,SACSA,GACP,GAAM+rB,GAAI3B,EAAOrT,EAAO,EAAG4D,IAAU,IAC/BqR,EAAIjV,EAAO,GAAI6D,EAAS,KACxByF,EAAO4L,EACXC,EAAOpd,IAAI,SAAAqd,GACT,MAAOC,GAAQD,GAAUJ,IAAGC,SAI1BK,EAAYtV,EAAO,EAAG,GACtBuV,EAAYvV,GAAQ,GAAK,IAE/BwV,GAAAC,KAAKC,YAAYpM,GACf0L,EAAGM,EACHL,EAAGM,IAGLC,EAAAG,MAAMC,IAAId,EAAWxL,MAIzB,QAAS+L,GAASD,EAAlBjE,GAA8D,GAAlC6D,GAAkC7D,EAAlC6D,EAAGC,EAA+B9D,EAA/B8D,CAC7B,OAAOO,GAAAK,OAAOC,UAAUd,EAAGC,EAAGG,EAAOxR,MAAQ,EAAI,EAAGwR,EAAOvR,OAAS,EAAI,GACtEkS,SAAU,EACVC,YAAa,EACbC,MAAOjW,EAAiB,IAAVD,KAAKmW,GAAWnW,KAAKmW,IACnC7iB,QACE8iB,YAAa,OACbf,QACEgB,iCAAkChB,EAAOiB,OACzCC,OAAQ,GACRC,OAAQ,O3B+uGhB7sB,OAAOC,eAAeZ,EAAS,cAC7B6E,OAAO,IAET7E,EAAQ4rB,UAAQtpB,E2B35GhB,IAAAmqB,GAAA5sB,EAAA,IAWQoX,E3Bo5GKwV,EAAUgB,O2Bp5GfxW,OAAQkV,E3Bq5GHM,EAAUgB,O2Br5GPtB,OAEVC,IAEFvR,MAAO,GACPC,OAAQ,IACRwS,OACE,qoEAGFzS,MAAO,GACPC,OAAQ,IACRwS,OACE,qtIAGFzS,MAAO,GACPC,OAAQ,IACRwS,OACE,qzEAGFzS,MAAO,GACPC,OAAQ,GACRwS,OACE,qvEAGFzS,MAAO,GACPC,OAAQ,GACRwS,OACE,qzCAIFzS,MAAO,GACPC,OAAQ,IACRwS,OACE,6uCAIFzS,MAAO,GACPC,OAAQ,IACRwS,OACE,6oBAUA1B,EAAQ,SAACF,EAAkB7gB,GAC/B,GAAM6iB,GAASjB,EAAAkB,OAAO9d,SACdgL,EAA+BhQ,EAA/BgQ,MAAOC,EAAwBjQ,EAAxBiQ,OAAQkO,EAAgBne,EAAhBme,YAEjB1e,EAASmiB,EAAAmB,OAAO/d,QACpB+N,QAAS8N,EACTgC,OAAQA,EACRjrB,SACEoY,QACAC,SACA+S,YAAY,EACZC,WAAY,gBAIhBrB,GAAAmB,OAAOzX,IAAI7L,EAEX,IAAMyjB,GAAStB,EAAAuB,OAAOne,QACtB4c,GAAAuB,OAAO7X,IAAI4X,EAAQL,GAEnB7f,WAAW,WACTmb,EAAY+E,EAAO9F,MAClB,KAEHlT,YAAY,WACViU,EAAY+E,EAAO9F,MAClB,IAEH,IAAMgG,GAAQP,EAAOO,KACrBA,GAAMC,QAAQC,MAAQ,EAEtBpZ,YAAY,WACV,GAAMqZ,GAAiBH,EAAM7B,OAAOtd,OAClC,SAAAuG,GAAA,MAAQA,GAAKgZ,SAASpC,EAAIpR,EAAQ,IAAMxF,EAAKgZ,SAASnC,EAAIpR,EAAS,KAErEsT,GAAezO,QAAQ,SAAAoM,GACrBU,EAAA6B,UAAUC,OAAON,EAAOlC,KAE1BD,EAAqBmC,GACnBjC,eAAgBoC,EAAelsB,OAC/B2Y,QACAC,YAED,IAEH,IAAM0T,GAAkB3T,EAAQ,CAIhCiR,GAAqBmC,GAASjC,eAD5BwC,EAFwB,QAEkCA,EACd3T,QAAOC,SAAQwP,MAAM,IAEnEmC,EAAAG,MAAMC,IAAIoB,GACRxB,EAAAK,OAAOC,UAAUlS,EAAQ,EAAGC,EAAS,IAAKD,EAAQ,IAAK,GACrD4T,UAAU,EACVnkB,QAAUokB,UAAW,iBAEvBjC,EAAAK,OAAOC,UAAUlS,EAAQ,EAAG,GAAIA,EAAQ,IAAK,GAC3C4T,UAAU,EACVnkB,QAAUokB,UAAW,mB3Bo7G3B1uB,G2Bj4GS4rB,S3Bq4GH,SAAU3rB,EAAQD,EAASH,GAEjC,cAC4B,SAASsS,GAAS,GAAIsS,GAAgCC,EAA8BC,EAAkCgK,EAAYA,EAE1J3pB,EAA4B,kBAAXuI,SAAoD,gBAApBA,QAAOC,SAAwB,SAAU5K,GAAO,aAAcA,IAAS,SAAUA,GAAO,MAAOA,IAAyB,kBAAX2K,SAAyB3K,EAAIqH,cAAgBsD,QAAU3K,IAAQ2K,OAAOnM,UAAY,eAAkBwB,K4B7hHtQ,SAAU8F,GAAG,GAAoB,WAAjB1D,EAAOhF,QAAoC,KAATC,EAAsBA,EAAOD,QAAQ0I,QAAS,CAA2Cgc,KAAAD,EAAA,MAAAniB,MAAAqiB,EAAA,kBAAAF,KAAA7T,MAAA5Q,EAAA0kB,GAAAD,KAAAxkB,EAAAD,QAAA2kB,KAAuL,WAAqC,MAAQ,SAASxe,GAAEuG,EAAE1L,EAAE4jB,GAAG,QAASrjB,GAAEb,EAAEkuB,GAAG,IAAI5tB,EAAEN,GAAG,CAAC,IAAIgM,EAAEhM,GAAG,CAAC,GAAIyH,GAAkB,kBAATwmB,IAAqBA,CAAQ,KAAIC,GAAGzmB,EAAE,MAAOwmB,GAAEjuB,GAAE,EAAI,IAAGR,EAAE,MAAOA,GAAEQ,GAAE,EAAI,IAAIgI,GAAE,GAAI0J,OAAM,uBAAuB1R,EAAE,IAAK,MAAMgI,GAAEmmB,KAAK,mBAAmBnmB,EAAE,GAAIvI,GAAEa,EAAEN,IAAIV,WAAY0M,GAAEhM,GAAG,GAAGN,KAAKD,EAAEH,QAAQ,SAASmG,GAAG,GAAInF,GAAE0L,EAAEhM,GAAG,GAAGyF,EAAG,OAAO5E,GAAEP,GAAImF,IAAIhG,EAAEA,EAAEH,QAAQmG,EAAEuG,EAAE1L,EAAE4jB,GAAG,MAAO5jB,GAAEN,GAAGV,QAAkD,IAAI,GAA1CE,GAAkB,kBAATyuB,IAAqBA,EAAgBjuB,EAAE,EAAEA,EAAEkkB,EAAE1iB,OAAOxB,IAAIa,EAAEqjB,EAAElkB,GAAI,OAAOa,KAAKutB,GAAG,SAASC,EAAQ9uB,EAAOD,GAWr0B,GAAI0sB,KAEJzsB,GAAOD,QAAU0sB,CAEjB,IAAIsC,GAAWD,EAAQ,wBACnBE,EAASF,EAAQ,sBACjBG,EAAWH,EAAQ,oBAEnBtB,GADSsB,EAAQ,oBACRA,EAAQ,mBACjBI,EAASJ,EAAQ,sBACjBK,EAAOL,EAAQ,qBAEnB,WAEIrC,EAAK2C,cAAgB,EACrB3C,EAAK4C,sBAAwB,EAC7B5C,EAAK6C,0BAA4B,EACjC7C,EAAK8C,cAAgB,EAWrB9C,EAAK7c,OAAS,SAASpN,GACnB,GAAIgtB,IACA/a,GAAI+Y,EAAOiC,SACXrpB,KAAM,OACNyc,MAAO,OACPjE,SACA8Q,UACAzC,MAAO,EACP0C,SAAUZ,EAASa,SAAS,+BAC5BxB,UAAYpC,EAAG,EAAGC,EAAG,GACrB4D,OAAS7D,EAAG,EAAGC,EAAG,GAClB6D,OAAQ,EACRC,iBAAmB/D,EAAG,EAAGC,EAAG,GAC5B+D,mBAAqBhE,EAAG,EAAGC,EAAG,EAAGgB,MAAO,GACxCgD,cAAe,EACfC,MAAO,EACPC,aAAc,EACdC,UAAYpE,EAAG,EAAGC,EAAG,GACrBoE,gBAAiB,EACjBC,UAAU,EACV9B,UAAU,EACV+B,YAAY,EACZC,OAAQ,EACRC,eAAgB,GAChBC,QAAS,KACTC,YAAa,EACb5D,SAAU,GACV6D,eAAgB,GAChB5D,YAAa,IACb6D,iBACIjO,SAAU,EACVkO,KAAM,WACNC,MAAO,GAEXC,KAAM,IACNC,UAAW,EACX5mB,QACI6mB,SAAS,EACTC,QAAS,EACT/E,QACIkB,OAAQ,EACRC,OAAQ,EACR6D,QAAS,EACTC,QAAS,GAEbC,UAAW,IAIfhR,EAAOkN,EAAO9qB,OAAO8sB,EAAUhtB,EAInC,OAFA+uB,GAAgBjR,EAAM9d,GAEf8d,GAWXmM,EAAK+E,UAAY,SAASC,GACtB,MAAIA,GACOhF,EAAK6C,2BAET7C,EAAK4C,yBAShB5C,EAAKiF,aAAe,WAEhB,MADAjF,GAAK8C,cAAgB9C,EAAK8C,eAAiB,EACpC9C,EAAK8C,cAUhB,IAAIgC,GAAkB,SAASjR,EAAM9d,GACjCA,EAAUA,MAGViqB,EAAKkF,IAAIrR,GACLsR,OAAQtR,EAAKsR,QAAU1C,EAAOtf,OAAO0Q,EAAKqP,UAC1CkC,aAAcvR,EAAKuR,cAAgB7C,EAAO8C,MAAMxR,EAAK8N,UACrD2D,UAAWzR,EAAKyR,WAAazR,EAAK2M,MAClC0C,SAAUrP,EAAKqP,SACf/Q,MAAO0B,EAAK1B,QAAU0B,GACtBkO,SAAUlO,EAAKkO,SACf+B,WAAYjQ,EAAKiQ,WACjBzpB,OAAQwZ,EAAKxZ,QAAUwZ,IAG3ByO,EAASiD,OAAO1R,EAAKqP,SAAUrP,EAAK2M,MAAO3M,EAAK8N,UAChDe,EAAK6C,OAAO1R,EAAK2R,KAAM3R,EAAK2M,OAC5BiC,EAAOgD,OAAO5R,EAAKsR,OAAQtR,EAAKqP,SAAUrP,EAAK8P,UAG/C3D,EAAKkF,IAAIrR,GACL2R,KAAMzvB,EAAQyvB,MAAQ3R,EAAK2R,KAC3BE,KAAM3vB,EAAQ2vB,MAAQ7R,EAAK6R,KAC3BC,KAAM5vB,EAAQ4vB,MAAQ9R,EAAK8R,KAC3BC,QAAS7vB,EAAQ6vB,SAAW/R,EAAK+R,SAIrC,IAAIC,GAAoBhS,EAAKkO,SAAW,UAAYhB,EAAOtB,QAAQ,UAAW,UAAW,UAAW,UAAW,WAE/G5L,GAAKjW,OAAOokB,UAAYnO,EAAKjW,OAAOokB,WAAa6D,EACjDhS,EAAKjW,OAAO8iB,YAAc7M,EAAKjW,OAAO8iB,aAFb,OAGzB7M,EAAKjW,OAAO+hB,OAAOgF,WAAa9Q,EAAKsR,OAAO7oB,IAAIijB,EAAI1L,EAAK8N,SAASpC,IAAM1L,EAAKsR,OAAOhV,IAAIoP,EAAI1L,EAAKsR,OAAO7oB,IAAIijB,GAC5G1L,EAAKjW,OAAO+hB,OAAOiF,WAAa/Q,EAAKsR,OAAO7oB,IAAIkjB,EAAI3L,EAAK8N,SAASnC,IAAM3L,EAAKsR,OAAOhV,IAAIqP,EAAI3L,EAAKsR,OAAO7oB,IAAIkjB,GAWhHQ,GAAKkF,IAAM,SAASrR,EAAMiS,EAAU3tB,GAChC,GAAI1D,EAEoB,iBAAbqxB,KACPrxB,EAAWqxB,EACXA,KACAA,EAASrxB,GAAY0D,EAGzB,KAAK1D,IAAYqxB,GAGb,GAFA3tB,EAAQ2tB,EAASrxB,GAEZqxB,EAASnxB,eAAeF,GAG7B,OAAQA,GAER,IAAK,WACDurB,EAAK+F,UAAUlS,EAAM1b,EACrB,MACJ,KAAK,aACDqqB,EAAS0C,IAAIrR,EAAM1b,EACnB,MACJ,KAAK,OACD6nB,EAAKgG,QAAQnS,EAAM1b,EACnB,MACJ,KAAK,UACD6nB,EAAKiG,WAAWpS,EAAM1b,EACtB,MACJ,KAAK,UACD6nB,EAAKkG,WAAWrS,EAAM1b,EACtB,MACJ,KAAK,WACD6nB,EAAKmG,YAAYtS,EAAM1b,EACvB,MACJ,KAAK,WACD6nB,EAAKoG,YAAYvS,EAAM1b,EACvB,MACJ,KAAK,QACD6nB,EAAKqG,SAASxS,EAAM1b,EACpB,MACJ,KAAK,WACD6nB,EAAKC,YAAYpM,EAAM1b,EACvB,MACJ,KAAK,kBACD6nB,EAAKsG,mBAAmBzS,EAAM1b,EAC9B,MACJ,KAAK,QACD6nB,EAAKuG,SAAS1S,EAAM1b,EACpB,MACJ,SACI0b,EAAKpf,GAAY0D,IAY7B6nB,EAAK+F,UAAY,SAASlS,EAAMkO,GAC5B,IAAK,GAAIvuB,GAAI,EAAGA,EAAIqgB,EAAK1B,MAAM3c,OAAQhC,IAAK,CACxC,GAAIgzB,GAAO3S,EAAK1B,MAAM3e,EACtBgzB,GAAKzE,SAAWA,EAEZA,GACAyE,EAAKC,WACDvC,YAAasC,EAAKtC,YAClB5D,SAAUkG,EAAKlG,SACfqF,KAAMa,EAAKb,KACXC,QAASY,EAAKZ,QACd3B,QAASuC,EAAKvC,QACdyC,YAAaF,EAAKE,YAClBC,eAAgBH,EAAKG,gBAGzBH,EAAKtC,YAAc,EACnBsC,EAAKlG,SAAW,EAChBkG,EAAKb,KAAOa,EAAKZ,QAAUY,EAAKvC,QAAU2C,IAC1CJ,EAAKE,YAAcF,EAAKG,eAAiB,EAEzCH,EAAKpB,aAAa7F,EAAIiH,EAAK7E,SAASpC,EACpCiH,EAAKpB,aAAa5F,EAAIgH,EAAK7E,SAASnC,EACpCgH,EAAKlB,UAAYkB,EAAKhG,MACtBgG,EAAK5C,gBAAkB,EACvB4C,EAAK/C,MAAQ,EACb+C,EAAK9C,aAAe,EACpB8C,EAAKzC,OAAS,GACPyC,EAAKC,YACZD,EAAKtC,YAAcsC,EAAKC,UAAUvC,YAClCsC,EAAKlG,SAAWkG,EAAKC,UAAUnG,SAC/BkG,EAAKb,KAAOa,EAAKC,UAAUd,KAC3Ba,EAAKZ,QAAUY,EAAKC,UAAUb,QAC9BY,EAAKvC,QAAUuC,EAAKC,UAAUxC,QAC9BuC,EAAKE,YAAcF,EAAKC,UAAUC,YAClCF,EAAKG,eAAiBH,EAAKC,UAAUE,qBAE9BH,GAAKC,aAWxBzG,EAAKgG,QAAU,SAASnS,EAAM8R,GAC1B,GAAIkB,GAAShT,EAAK+R,SAAW/R,EAAK8R,KAAO,EACzC9R,GAAK+R,QAAUiB,GAAUlB,EAAO,GAChC9R,EAAK8S,eAAiB,EAAI9S,EAAK+R,QAE/B/R,EAAK8R,KAAOA,EACZ9R,EAAK6S,YAAc,EAAI7S,EAAK8R,KAC5B9R,EAAKoQ,QAAUpQ,EAAK8R,KAAO9R,EAAK6R,MASpC1F,EAAKiG,WAAa,SAASpS,EAAMoQ,GAC7BjE,EAAKgG,QAAQnS,EAAMoQ,EAAUpQ,EAAK6R,MAClC7R,EAAKoQ,QAAUA,GAUnBjE,EAAKkG,WAAa,SAASrS,EAAM+R,GAC7B/R,EAAK+R,QAAUA,EACf/R,EAAK8S,eAAiB,EAAI9S,EAAK+R,SAenC5F,EAAKmG,YAAc,SAAStS,EAAMqP,GAE1BA,EAAS,GAAGrP,OAASA,EACrBA,EAAKqP,SAAWA,EAEhBrP,EAAKqP,SAAWZ,EAASnf,OAAO+f,EAAUrP,GAI9CA,EAAK2R,KAAO9C,EAAKoE,aAAajT,EAAKqP,UACnCrP,EAAK6R,KAAOpD,EAASoD,KAAK7R,EAAKqP,UAC/BlD,EAAKgG,QAAQnS,EAAMA,EAAKoQ,QAAUpQ,EAAK6R,KAGvC,IAAIqB,GAASzE,EAASyE,OAAOlT,EAAKqP,SAClCZ,GAAS0E,UAAUnT,EAAKqP,SAAU6D,GAAS,GAG3C/G,EAAKkG,WAAWrS,EAAMmM,EAAK2C,cAAgBL,EAASsD,QAAQ/R,EAAKqP,SAAUrP,EAAK8R,OAGhFrD,EAAS0E,UAAUnT,EAAKqP,SAAUrP,EAAK8N,UACvCc,EAAOgD,OAAO5R,EAAKsR,OAAQtR,EAAKqP,SAAUrP,EAAK8P,WAanD3D,EAAKuG,SAAW,SAAS1S,EAAM1B,EAAO8U,GAClC,GAAIzzB,EAQJ,KALA2e,EAAQA,EAAM9b,MAAM,GACpBwd,EAAK1B,MAAM3c,OAAS,EACpBqe,EAAK1B,MAAMzc,KAAKme,GAChBA,EAAKxZ,OAASwZ,EAETrgB,EAAI,EAAGA,EAAI2e,EAAM3c,OAAQhC,IAAK,CAC/B,GAAIgzB,GAAOrU,EAAM3e,EACbgzB,KAAS3S,IACT2S,EAAKnsB,OAASwZ,EACdA,EAAK1B,MAAMzc,KAAK8wB,IAIxB,GAA0B,IAAtB3S,EAAK1B,MAAM3c,OAAf,CAMA,GAHAyxB,MAA+B,KAAbA,GAA2BA,EAG/B,CACV,GAAI/D,KACJ,KAAK1vB,EAAI,EAAGA,EAAI2e,EAAM3c,OAAQhC,IAC1B0vB,EAAWA,EAAS/gB,OAAOgQ,EAAM3e,GAAG0vB,SAGxCZ,GAAS4E,cAAchE,EAEvB,IAAIiE,GAAO7E,EAAS6E,KAAKjE,GACrBkE,EAAa9E,EAASyE,OAAOI,EAEjCnH,GAAKmG,YAAYtS,EAAMsT,GACvB7E,EAAS0E,UAAUnT,EAAKqP,SAAUkE,GAItC,GAAIC,GAAQrH,EAAKsH,iBAAiBzT,EAElCA,GAAK6R,KAAO2B,EAAM3B,KAClB7R,EAAKxZ,OAASwZ,EACdA,EAAK8N,SAASpC,EAAI8H,EAAMN,OAAOxH,EAC/B1L,EAAK8N,SAASnC,EAAI6H,EAAMN,OAAOvH,EAC/B3L,EAAKuR,aAAa7F,EAAI8H,EAAMN,OAAOxH,EACnC1L,EAAKuR,aAAa5F,EAAI6H,EAAMN,OAAOvH,EAEnCQ,EAAKgG,QAAQnS,EAAMwT,EAAM1B,MACzB3F,EAAKkG,WAAWrS,EAAMwT,EAAMzB,SAC5B5F,EAAKoG,YAAYvS,EAAMwT,EAAMN,UASjC/G,EAAKoG,YAAc,SAASvS,EAAM8N,GAC9B,GAAI4F,GAAQhF,EAAOiF,IAAI7F,EAAU9N,EAAK8N,SACtC9N,GAAKuR,aAAa7F,GAAKgI,EAAMhI,EAC7B1L,EAAKuR,aAAa5F,GAAK+H,EAAM/H,CAE7B,KAAK,GAAIhsB,GAAI,EAAGA,EAAIqgB,EAAK1B,MAAM3c,OAAQhC,IAAK,CACxC,GAAIgzB,GAAO3S,EAAK1B,MAAM3e,EACtBgzB,GAAK7E,SAASpC,GAAKgI,EAAMhI,EACzBiH,EAAK7E,SAASnC,GAAK+H,EAAM/H,EACzB8C,EAAS0E,UAAUR,EAAKtD,SAAUqE,GAClC9E,EAAOgD,OAAOe,EAAKrB,OAAQqB,EAAKtD,SAAUrP,EAAK8P,YAUvD3D,EAAKqG,SAAW,SAASxS,EAAM2M,GAC3B,GAAI+G,GAAQ/G,EAAQ3M,EAAK2M,KACzB3M,GAAKyR,WAAaiC,CAElB,KAAK,GAAI/zB,GAAI,EAAGA,EAAIqgB,EAAK1B,MAAM3c,OAAQhC,IAAK,CACxC,GAAIgzB,GAAO3S,EAAK1B,MAAM3e,EACtBgzB,GAAKhG,OAAS+G,EACdjF,EAASiD,OAAOiB,EAAKtD,SAAUqE,EAAO1T,EAAK8N,UAC3Ce,EAAK6C,OAAOiB,EAAKhB,KAAM+B,GACvB9E,EAAOgD,OAAOe,EAAKrB,OAAQqB,EAAKtD,SAAUrP,EAAK8P,UAC3CnwB,EAAI,GACJ+uB,EAAOkF,YAAYjB,EAAK7E,SAAU4F,EAAO1T,EAAK8N,SAAU6E,EAAK7E,YAWzE3B,EAAKC,YAAc,SAASpM,EAAM8P,GAC9B9P,EAAKuR,aAAa7F,EAAI1L,EAAK8N,SAASpC,EAAIoE,EAASpE,EACjD1L,EAAKuR,aAAa5F,EAAI3L,EAAK8N,SAASnC,EAAImE,EAASnE,EACjD3L,EAAK8P,SAASpE,EAAIoE,EAASpE,EAC3B1L,EAAK8P,SAASnE,EAAImE,EAASnE,EAC3B3L,EAAK4P,MAAQlB,EAAOmF,UAAU7T,EAAK8P,WASvC3D,EAAKsG,mBAAqB,SAASzS,EAAM8P,GACrC9P,EAAKyR,UAAYzR,EAAK2M,MAAQmD,EAC9B9P,EAAK+P,gBAAkBD,EACvB9P,EAAK6P,aAAepZ,KAAKqd,IAAI9T,EAAK+P,kBAStC5D,EAAKgH,UAAY,SAASnT,EAAM+T,GAC5B5H,EAAKoG,YAAYvS,EAAM0O,EAAOpC,IAAItM,EAAK8N,SAAUiG,KAUrD5H,EAAKuF,OAAS,SAAS1R,EAAMgU,EAAUC,GACnC,GAAKA,EAEE,CACH,GAAIC,GAAMzd,KAAKyd,IAAIF,GACfG,EAAM1d,KAAK0d,IAAIH,GACfI,EAAKpU,EAAK8N,SAASpC,EAAIuI,EAAMvI,EAC7B2I,EAAKrU,EAAK8N,SAASnC,EAAIsI,EAAMtI,CAEjCQ,GAAKoG,YAAYvS,GACb0L,EAAGuI,EAAMvI,GAAK0I,EAAKF,EAAMG,EAAKF,GAC9BxI,EAAGsI,EAAMtI,GAAKyI,EAAKD,EAAME,EAAKH,KAGlC/H,EAAKqG,SAASxS,EAAMA,EAAK2M,MAAQqH,OAZjC7H,GAAKqG,SAASxS,EAAMA,EAAK2M,MAAQqH,IAwBzC7H,EAAKyB,MAAQ,SAAS5N,EAAMsU,EAAQC,EAAQN,GACxC,GAAIO,GAAY,EACZC,EAAe,CAEnBR,GAAQA,GAASjU,EAAK8N,QAEtB,KAAK,GAAInuB,GAAI,EAAGA,EAAIqgB,EAAK1B,MAAM3c,OAAQhC,IAAK,CACxC,GAAIgzB,GAAO3S,EAAK1B,MAAM3e,EAGtB8uB,GAASb,MAAM+E,EAAKtD,SAAUiF,EAAQC,EAAQN,GAG9CtB,EAAKhB,KAAO9C,EAAKoE,aAAaN,EAAKtD,UACnCsD,EAAKd,KAAOpD,EAASoD,KAAKc,EAAKtD,UAC/BlD,EAAKgG,QAAQQ,EAAM3S,EAAKoQ,QAAUuC,EAAKd,MAGvCpD,EAAS0E,UAAUR,EAAKtD,UAAY3D,GAAIiH,EAAK7E,SAASpC,EAAGC,GAAIgH,EAAK7E,SAASnC,IAC3EQ,EAAKkG,WAAWM,EAAMxG,EAAK2C,cAAgBL,EAASsD,QAAQY,EAAKtD,SAAUsD,EAAKb,OAChFrD,EAAS0E,UAAUR,EAAKtD,UAAY3D,EAAGiH,EAAK7E,SAASpC,EAAGC,EAAGgH,EAAK7E,SAASnC,IAErEhsB,EAAI,IACJ60B,GAAa7B,EAAKd,KAClB4C,GAAgB9B,EAAKZ,SAIzBY,EAAK7E,SAASpC,EAAIuI,EAAMvI,GAAKiH,EAAK7E,SAASpC,EAAIuI,EAAMvI,GAAK4I,EAC1D3B,EAAK7E,SAASnC,EAAIsI,EAAMtI,GAAKgH,EAAK7E,SAASnC,EAAIsI,EAAMtI,GAAK4I,EAG1D3F,EAAOgD,OAAOe,EAAKrB,OAAQqB,EAAKtD,SAAUrP,EAAK8P,UAI/C9P,EAAK1B,MAAM3c,OAAS,IACpBqe,EAAK6R,KAAO2C,EAEPxU,EAAKkO,WACN/B,EAAKgG,QAAQnS,EAAMA,EAAKoQ,QAAUoE,GAClCrI,EAAKkG,WAAWrS,EAAMyU,KAK1BzU,EAAK0U,eACDJ,IAAWC,EACXvU,EAAK0U,cAAgBJ,EAGrBtU,EAAK0U,aAAe,OAahCvI,EAAKyF,OAAS,SAAS5R,EAAM2U,EAAWhE,EAAWiE,GAC/C,GAAIC,GAAmBpe,KAAKqe,IAAIH,EAAYhE,EAAY3Q,EAAK2Q,UAAW,GAGpEjE,EAAc,EAAI1M,EAAK0M,YAAciE,EAAY3Q,EAAK2Q,UACtDoE,EAAgB/U,EAAK8N,SAASpC,EAAI1L,EAAKuR,aAAa7F,EACpDsJ,EAAgBhV,EAAK8N,SAASnC,EAAI3L,EAAKuR,aAAa5F,CAGxD3L,GAAK8P,SAASpE,EAAKqJ,EAAgBrI,EAAckI,EAAe5U,EAAKuP,MAAM7D,EAAI1L,EAAK8R,KAAQ+C,EAC5F7U,EAAK8P,SAASnE,EAAKqJ,EAAgBtI,EAAckI,EAAe5U,EAAKuP,MAAM5D,EAAI3L,EAAK8R,KAAQ+C,EAE5F7U,EAAKuR,aAAa7F,EAAI1L,EAAK8N,SAASpC,EACpC1L,EAAKuR,aAAa5F,EAAI3L,EAAK8N,SAASnC,EACpC3L,EAAK8N,SAASpC,GAAK1L,EAAK8P,SAASpE,EACjC1L,EAAK8N,SAASnC,GAAK3L,EAAK8P,SAASnE,EAGjC3L,EAAK+P,iBAAoB/P,EAAK2M,MAAQ3M,EAAKyR,WAAa/E,EAAckI,EAAe5U,EAAKwP,OAASxP,EAAK+R,QAAW8C,EACnH7U,EAAKyR,UAAYzR,EAAK2M,MACtB3M,EAAK2M,OAAS3M,EAAK+P,gBAGnB/P,EAAK4P,MAAQlB,EAAOmF,UAAU7T,EAAK8P,UACnC9P,EAAK6P,aAAepZ,KAAKqd,IAAI9T,EAAK+P,gBAGlC,KAAK,GAAIpwB,GAAI,EAAGA,EAAIqgB,EAAK1B,MAAM3c,OAAQhC,IAAK,CACxC,GAAIgzB,GAAO3S,EAAK1B,MAAM3e,EAEtB8uB,GAAS0E,UAAUR,EAAKtD,SAAUrP,EAAK8P,UAEnCnwB,EAAI,IACJgzB,EAAK7E,SAASpC,GAAK1L,EAAK8P,SAASpE,EACjCiH,EAAK7E,SAASnC,GAAK3L,EAAK8P,SAASnE,GAGR,IAAzB3L,EAAK+P,kBACLtB,EAASiD,OAAOiB,EAAKtD,SAAUrP,EAAK+P,gBAAiB/P,EAAK8N,UAC1De,EAAK6C,OAAOiB,EAAKhB,KAAM3R,EAAK+P,iBACxBpwB,EAAI,GACJ+uB,EAAOkF,YAAYjB,EAAK7E,SAAU9N,EAAK+P,gBAAiB/P,EAAK8N,SAAU6E,EAAK7E,WAIpFc,EAAOgD,OAAOe,EAAKrB,OAAQqB,EAAKtD,SAAUrP,EAAK8P,YAWvD3D,EAAK8I,WAAa,SAASjV,EAAM8N,EAAUyB,GACvCvP,EAAKuP,MAAM7D,GAAK6D,EAAM7D,EACtB1L,EAAKuP,MAAM5D,GAAK4D,EAAM5D,CACtB,IAAIuJ,IAAWxJ,EAAGoC,EAASpC,EAAI1L,EAAK8N,SAASpC,EAAGC,EAAGmC,EAASnC,EAAI3L,EAAK8N,SAASnC,EAC9E3L,GAAKwP,QAAU0F,EAAOxJ,EAAI6D,EAAM5D,EAAIuJ,EAAOvJ,EAAI4D,EAAM7D,GAUzDS,EAAKsH,iBAAmB,SAASzT,GAa7B,IAAK,GARDmV,IACArD,KAAM,EACND,KAAM,EACNE,QAAS,EACTmB,QAAUxH,EAAG,EAAGC,EAAG,IAIdhsB,EAA0B,IAAtBqgB,EAAK1B,MAAM3c,OAAe,EAAI,EAAGhC,EAAIqgB,EAAK1B,MAAM3c,OAAQhC,IAAK,CACtE,GAAIgzB,GAAO3S,EAAK1B,MAAM3e,GAClBmyB,EAAOa,EAAKb,OAASiB,IAAWJ,EAAKb,KAAO,CAEhDqD,GAAWrD,MAAQA,EACnBqD,EAAWtD,MAAQc,EAAKd,KACxBsD,EAAWpD,SAAWY,EAAKZ,QAC3BoD,EAAWjC,OAASxE,EAAOpC,IAAI6I,EAAWjC,OAAQxE,EAAO0G,KAAKzC,EAAK7E,SAAUgE,IAKjF,MAFAqD,GAAWjC,OAASxE,EAAO2G,IAAIF,EAAWjC,OAAQiC,EAAWrD,MAEtDqD,QA4fZG,iBAAiB,GAAGC,mBAAmB,GAAGC,mBAAmB,GAAGC,qBAAqB,GAAGC,qBAAqB,GAAGC,uBAAuB,GAAGC,mBAAmB,KAAKC,GAAG,SAASrH,EAAQ9uB,EAAOD,GAYhM,GAAIsuB,KAEJruB,GAAOD,QAAUsuB,CAEjB,IAAI+H,GAAStH,EAAQ,kBACjBtB,EAASsB,EAAQ,kBACjBrC,EAAOqC,EAAQ,WAEnB,WASIT,EAAUze,OAAS,SAASpN,GACxB,MAAOgrB,GAAO9qB,QACV+R,GAAI+Y,EAAOiC,SACXrpB,KAAM,YACNU,OAAQ,KACRuvB,YAAY,EACZlK,UACAmK,eACAC,cACA1T,MAAO,YACP6M,WACDltB,IAaP6rB,EAAUmI,YAAc,SAAS1K,EAAWuK,EAAYI,EAAeC,GAOnE,GANA5K,EAAUuK,WAAaA,EAEnBI,GAAiB3K,EAAUhlB,QAC3BunB,EAAUmI,YAAY1K,EAAUhlB,OAAQuvB,EAAYI,EAAeC,GAGnEA,EACA,IAAI,GAAIz2B,GAAI,EAAGA,EAAI6rB,EAAUyK,WAAWt0B,OAAQhC,IAAK,CACjD,GAAI02B,GAAiB7K,EAAUyK,WAAWt2B,EAC1CouB,GAAUmI,YAAYG,EAAgBN,EAAYI,EAAeC,KAa7ErI,EAAUzB,IAAM,SAASd,EAAW7qB,GAChC,GAAI21B,MAAahoB,OAAO3N,EAExBm1B,GAAOS,QAAQ/K,EAAW,aAAe7qB,OAAQA,GAEjD,KAAK,GAAIhB,GAAI,EAAGA,EAAI22B,EAAQ30B,OAAQhC,IAAK,CACrC,GAAI0C,GAAMi0B,EAAQ32B,EAElB,QAAQ0C,EAAIyD,MAEZ,IAAK,OAED,GAAIzD,EAAImE,SAAWnE,EAAK,CACpB6qB,EAAOjZ,KAAK,uFACZ,OAGJ8Z,EAAUhC,QAAQP,EAAWnpB,EAC7B,MACJ,KAAK,aACD0rB,EAAUyI,cAAchL,EAAWnpB,EACnC,MACJ,KAAK,YACD0rB,EAAU0I,aAAajL,EAAWnpB,EAClC,MACJ,KAAK,kBACD0rB,EAAUyI,cAAchL,EAAWnpB,EAAIq0B,aAQ/C,MAFAZ,GAAOS,QAAQ/K,EAAW,YAAc7qB,OAAQA,IAEzC6qB,GAaXuC,EAAUC,OAAS,SAASxC,EAAW7qB,EAAQg2B,GAC3C,GAAIL,MAAahoB,OAAO3N,EAExBm1B,GAAOS,QAAQ/K,EAAW,gBAAkB7qB,OAAQA,GAEpD,KAAK,GAAIhB,GAAI,EAAGA,EAAI22B,EAAQ30B,OAAQhC,IAAK,CACrC,GAAI0C,GAAMi0B,EAAQ32B,EAElB,QAAQ0C,EAAIyD,MAEZ,IAAK,OACDioB,EAAU6I,WAAWpL,EAAWnpB,EAAKs0B,EACrC,MACJ,KAAK,aACD5I,EAAU8I,iBAAiBrL,EAAWnpB,EAAKs0B,EAC3C,MACJ,KAAK,YACD5I,EAAU+I,gBAAgBtL,EAAWnpB,EAAKs0B,EAC1C,MACJ,KAAK,kBACD5I,EAAU8I,iBAAiBrL,EAAWnpB,EAAIq0B,aAQlD,MAFAZ,GAAOS,QAAQ/K,EAAW,eAAiB7qB,OAAQA,IAE5C6qB,GAWXuC,EAAU0I,aAAe,SAASM,EAAYC,GAI1C,MAHAD,GAAWd,WAAWp0B,KAAKm1B,GAC3BA,EAAWxwB,OAASuwB,EACpBhJ,EAAUmI,YAAYa,GAAY,GAAM,GAAM,GACvCA,GAYXhJ,EAAU+I,gBAAkB,SAASC,EAAYC,EAAYL,GACzD,GAAI7I,GAAWZ,EAAOrW,QAAQkgB,EAAWd,WAAYe,EAMrD,KALkB,IAAdlJ,IACAC,EAAUkJ,kBAAkBF,EAAYjJ,GACxCC,EAAUmI,YAAYa,GAAY,GAAM,GAAM,IAG9CJ,EACA,IAAK,GAAIh3B,GAAI,EAAGA,EAAIo3B,EAAWd,WAAWt0B,OAAQhC,IAC9CouB,EAAU+I,gBAAgBC,EAAWd,WAAWt2B,GAAIq3B,GAAY,EAIxE,OAAOD,IAWXhJ,EAAUkJ,kBAAoB,SAASzL,EAAWsC,GAG9C,MAFAtC,GAAUyK,WAAW9rB,OAAO2jB,EAAU,GACtCC,EAAUmI,YAAY1K,GAAW,GAAM,GAAM,GACtCA,GAWXuC,EAAUhC,QAAU,SAASP,EAAWxL,GAGpC,MAFAwL,GAAUK,OAAOhqB,KAAKme,GACtB+N,EAAUmI,YAAY1K,GAAW,GAAM,GAAM,GACtCA,GAYXuC,EAAU6I,WAAa,SAASpL,EAAWxL,EAAM2W,GAC7C,GAAI7I,GAAWZ,EAAOrW,QAAQ2U,EAAUK,OAAQ7L,EAMhD,KALkB,IAAd8N,IACAC,EAAUmJ,aAAa1L,EAAWsC,GAClCC,EAAUmI,YAAY1K,GAAW,GAAM,GAAM,IAG7CmL,EACA,IAAK,GAAIh3B,GAAI,EAAGA,EAAI6rB,EAAUyK,WAAWt0B,OAAQhC,IAC7CouB,EAAU6I,WAAWpL,EAAUyK,WAAWt2B,GAAIqgB,GAAM,EAI5D,OAAOwL,IAWXuC,EAAUmJ,aAAe,SAAS1L,EAAWsC,GAGzC,MAFAtC,GAAUK,OAAO1hB,OAAO2jB,EAAU,GAClCC,EAAUmI,YAAY1K,GAAW,GAAM,GAAM,GACtCA,GAWXuC,EAAUyI,cAAgB,SAAShL,EAAWkL,GAG1C,MAFAlL,GAAUwK,YAAYn0B,KAAK60B,GAC3B3I,EAAUmI,YAAY1K,GAAW,GAAM,GAAM,GACtCA,GAYXuC,EAAU8I,iBAAmB,SAASrL,EAAWkL,EAAYC,GACzD,GAAI7I,GAAWZ,EAAOrW,QAAQ2U,EAAUwK,YAAaU,EAKrD,KAJkB,IAAd5I,GACAC,EAAUoJ,mBAAmB3L,EAAWsC,GAGxC6I,EACA,IAAK,GAAIh3B,GAAI,EAAGA,EAAI6rB,EAAUyK,WAAWt0B,OAAQhC,IAC7CouB,EAAU8I,iBAAiBrL,EAAUyK,WAAWt2B,GAAI+2B,GAAY,EAIxE,OAAOlL,IAWXuC,EAAUoJ,mBAAqB,SAAS3L,EAAWsC,GAG/C,MAFAtC,GAAUwK,YAAY7rB,OAAO2jB,EAAU,GACvCC,EAAUmI,YAAY1K,GAAW,GAAM,GAAM,GACtCA,GAWXuC,EAAUqJ,MAAQ,SAAS5L,EAAW6L,EAAYV,GAC9C,GAAIA,EACA,IAAK,GAAIh3B,GAAI,EAAGA,EAAI6rB,EAAUyK,WAAWt0B,OAAQhC,IAC7CouB,EAAUqJ,MAAM5L,EAAUyK,WAAWt2B,GAAI03B,GAAY,EAc7D,OAVIA,GACA7L,EAAUK,OAASL,EAAUK,OAAOtd,OAAO,SAASyR,GAAQ,MAAOA,GAAKkO,WAExE1C,EAAUK,OAAOlqB,OAAS,EAG9B6pB,EAAUwK,YAAYr0B,OAAS,EAC/B6pB,EAAUyK,WAAWt0B,OAAS,EAC9BosB,EAAUmI,YAAY1K,GAAW,GAAM,GAAM,GAEtCA,GASXuC,EAAUuJ,UAAY,SAAS9L,GAG3B,IAAK,GAFDK,MAAYvd,OAAOkd,EAAUK,QAExBlsB,EAAI,EAAGA,EAAI6rB,EAAUyK,WAAWt0B,OAAQhC,IAC7CksB,EAASA,EAAOvd,OAAOyf,EAAUuJ,UAAU9L,EAAUyK,WAAWt2B,IAEpE,OAAOksB,IASXkC,EAAUwJ,eAAiB,SAAS/L,GAGhC,IAAK,GAFDwK,MAAiB1nB,OAAOkd,EAAUwK,aAE7Br2B,EAAI,EAAGA,EAAI6rB,EAAUyK,WAAWt0B,OAAQhC,IAC7Cq2B,EAAcA,EAAY1nB,OAAOyf,EAAUwJ,eAAe/L,EAAUyK,WAAWt2B,IAEnF,OAAOq2B,IASXjI,EAAUyJ,cAAgB,SAAShM,GAG/B,IAAK,GAFDyK,MAAgB3nB,OAAOkd,EAAUyK,YAE5Bt2B,EAAI,EAAGA,EAAI6rB,EAAUyK,WAAWt0B,OAAQhC,IAC7Cs2B,EAAaA,EAAW3nB,OAAOyf,EAAUyJ,cAAchM,EAAUyK,WAAWt2B,IAEhF,OAAOs2B,IAWXlI,EAAUvtB,IAAM,SAASgrB,EAAWrX,EAAIrO,GACpC,GAAIwwB,GACA31B,CAEJ,QAAQmF,GACR,IAAK,OACDwwB,EAAUvI,EAAUuJ,UAAU9L,EAC9B,MACJ,KAAK,aACD8K,EAAUvI,EAAUwJ,eAAe/L,EACnC,MACJ,KAAK,YACD8K,EAAUvI,EAAUyJ,cAAchM,GAAWld,OAAOkd,GAIxD,MAAK8K,IAGL31B,EAAS21B,EAAQ/nB,OAAO,SAAS5N,GAC7B,MAAOA,GAAOwT,GAAG8B,aAAe9B,EAAG8B,aAGd,IAAlBtV,EAAOgB,OAAe,KAAOhB,EAAO,IANhC,MAiBfotB,EAAU0J,KAAO,SAASV,EAAYT,EAASU,GAG3C,MAFAjJ,GAAUC,OAAO+I,EAAYT,GAC7BvI,EAAUzB,IAAI0K,EAAYV,GACnBS,GASXhJ,EAAU2J,OAAS,SAASlM,GAKxB,IAAK,GAJD8K,GAAUvI,EAAUuJ,UAAU9L,GACjBld,OAAOyf,EAAUwJ,eAAe/L,IAChCld,OAAOyf,EAAUyJ,cAAchM,IAEvC7rB,EAAI,EAAGA,EAAI22B,EAAQ30B,OAAQhC,IAChC22B,EAAQ32B,GAAGwU,GAAK+Y,EAAOiC,QAK3B,OAFApB,GAAUmI,YAAY1K,GAAW,GAAM,GAAM,GAEtCA,GAWXuC,EAAUoF,UAAY,SAAS3H,EAAWuI,EAAa4D,GAGnD,IAAK,GAFD9L,GAAS8L,EAAY5J,EAAUuJ,UAAU9L,GAAaA,EAAUK,OAE3DlsB,EAAI,EAAGA,EAAIksB,EAAOlqB,OAAQhC,IAC/BwsB,EAAKgH,UAAUtH,EAAOlsB,GAAIo0B,EAK9B,OAFAhG,GAAUmI,YAAY1K,GAAW,GAAM,GAAM,GAEtCA,GAWXuC,EAAU2D,OAAS,SAASlG,EAAWwI,EAAUC,EAAO0D,GAKpD,IAAK,GAJDzD,GAAMzd,KAAKyd,IAAIF,GACfG,EAAM1d,KAAK0d,IAAIH,GACfnI,EAAS8L,EAAY5J,EAAUuJ,UAAU9L,GAAaA,EAAUK,OAE3DlsB,EAAI,EAAGA,EAAIksB,EAAOlqB,OAAQhC,IAAK,CACpC,GAAIqgB,GAAO6L,EAAOlsB,GACdy0B,EAAKpU,EAAK8N,SAASpC,EAAIuI,EAAMvI,EAC7B2I,EAAKrU,EAAK8N,SAASnC,EAAIsI,EAAMtI,CAEjCQ,GAAKoG,YAAYvS,GACb0L,EAAGuI,EAAMvI,GAAK0I,EAAKF,EAAMG,EAAKF,GAC9BxI,EAAGsI,EAAMtI,GAAKyI,EAAKD,EAAME,EAAKH,KAGlC/H,EAAKuF,OAAO1R,EAAMgU,GAKtB,MAFAjG,GAAUmI,YAAY1K,GAAW,GAAM,GAAM,GAEtCA,GAYXuC,EAAUH,MAAQ,SAASpC,EAAW8I,EAAQC,EAAQN,EAAO0D,GAGzD,IAAK,GAFD9L,GAAS8L,EAAY5J,EAAUuJ,UAAU9L,GAAaA,EAAUK,OAE3DlsB,EAAI,EAAGA,EAAIksB,EAAOlqB,OAAQhC,IAAK,CACpC,GAAIqgB,GAAO6L,EAAOlsB,GACdy0B,EAAKpU,EAAK8N,SAASpC,EAAIuI,EAAMvI,EAC7B2I,EAAKrU,EAAK8N,SAASnC,EAAIsI,EAAMtI,CAEjCQ,GAAKoG,YAAYvS,GACb0L,EAAGuI,EAAMvI,EAAI0I,EAAKE,EAClB3I,EAAGsI,EAAMtI,EAAI0I,EAAKE,IAGtBpI,EAAKyB,MAAM5N,EAAMsU,EAAQC,GAK7B,MAFAxG,GAAUmI,YAAY1K,GAAW,GAAM,GAAM,GAEtCA,GASXuC,EAAUuD,OAAS,SAAS9F,GAIxB,IAAK,GAHDK,GAAS+L,OAAO7J,UAAUuJ,UAAU9L,GACpC6D,KAEK1vB,EAAI,EAAGA,EAAIksB,EAAOlqB,OAAQhC,GAAK,EAAG,CACvC,GAAIqgB,GAAO6L,EAAOlsB,EAClB0vB,GAASxtB,KAAKme,EAAKsR,OAAO7oB,IAAKuX,EAAKsR,OAAOhV,KAG/C,MAAOsb,QAAOhJ,OAAOtf,OAAO+f,SAwIjCiG,iBAAiB,GAAGuC,iBAAiB,GAAGC,SAAS,IAAIC,GAAG,SAASvJ,EAAQ9uB,EAAOD,GAcnF,GAAI4sB,KAEJ3sB,GAAOD,QAAU4sB,CAEjB,IAAI0B,GAAYS,EAAQ,eAEpBtB,GADasB,EAAQ,4BACZA,EAAQ,oBAErB,WAUInC,EAAM/c,OAAS,SAASpN,GACpB,GAAIspB,GAAYuC,EAAUze,SAEtB4f,GACA3M,MAAO,QACPoL,SACIjC,EAAG,EACHC,EAAG,EACHiC,MAAO,MAEX0D,QACI7oB,KAAOijB,GAAIqH,IAAUpH,GAAIoH,KACzBzW,KAAOoP,EAAGqH,IAAUpH,EAAGoH,MAI/B,OAAO7F,GAAO9qB,OAAOopB,EAAW0D,EAAUhtB,SAqG/C81B,2BAA2B,GAAG1C,iBAAiB,GAAG2C,cAAc,IAAIC,GAAG,SAAS1J,EAAQ9uB,EAAOD,GAOlG,GAAI04B,KAEJz4B,GAAOD,QAAU04B,EAEjB,WAQIA,EAAQ7oB,OAAS,SAAS8oB,GACtB,OACIjkB,GAAIgkB,EAAQhkB,GAAGikB,GACfA,OAAQA,EACRC,cAAe,EACfC,eAAgB,IAUxBH,EAAQhkB,GAAK,SAASikB,GAClB,MAAOA,GAAOpY,KAAK7L,GAAK,IAAMikB,EAAO5X,eAKvC+X,GAAG,SAAS/J,EAAQ9uB,EAAOD,GASjC,GAAI+4B,KAEJ94B,GAAOD,QAAU+4B,CAEjB,IAAIC,GAAMjK,EAAQ,SACdkK,EAAOlK,EAAQ,UACfI,EAASJ,EAAQ,uBAErB,WASIgK,EAASG,WAAa,SAASC,EAAiBzL,GAK5C,IAAK,GAJDwL,MACAE,EAAa1L,EAAO2L,MAAMC,MAGrBp5B,EAAI,EAAGA,EAAIi5B,EAAgBj3B,OAAQhC,IAAK,CAC7C,GAAIq5B,GAAQJ,EAAgBj5B,GAAG,GAC3Bs5B,EAAQL,EAAgBj5B,GAAG,EAE/B,MAAKq5B,EAAM9K,WAAY8K,EAAM/I,aAAgBgJ,EAAM/K,WAAY+K,EAAMhJ,cAGhEuI,EAASU,WAAWF,EAAMzI,gBAAiB0I,EAAM1I,kBAKlD3B,EAAOuK,SAASH,EAAM1H,OAAQ2H,EAAM3H,SACpC,IAAK,GAAIppB,GAAI8wB,EAAM1a,MAAM3c,OAAS,EAAI,EAAI,EAAGuG,EAAI8wB,EAAM1a,MAAM3c,OAAQuG,IAGjE,IAAK,GAFDkxB,GAAQJ,EAAM1a,MAAMpW,GAEfmxB,EAAIJ,EAAM3a,MAAM3c,OAAS,EAAI,EAAI,EAAG03B,EAAIJ,EAAM3a,MAAM3c,OAAQ03B,IAAK,CACtE,GAAIC,GAAQL,EAAM3a,MAAM+a,EAExB,IAAKD,IAAUJ,GAASM,IAAUL,GAAUrK,EAAOuK,SAASC,EAAM9H,OAAQgI,EAAMhI,QAAS,CAErF,GAEIiI,GAFAC,EAASd,EAAKvkB,GAAGilB,EAAOE,GACxBG,EAAOZ,EAAWW,EAIlBD,GADAE,GAAQA,EAAKC,SACOD,EAAKE,UAEL,IAIxB,IAAIA,GAAYlB,EAAImB,SAASR,EAAOE,EAAOC,EAGvCI,GAAUE,UACVlB,EAAW92B,KAAK83B,KAQxC,MAAOhB,IAWXH,EAASU,WAAa,SAASY,EAASC,GACpC,MAAID,GAAQrJ,QAAUsJ,EAAQtJ,OAA2B,IAAlBqJ,EAAQrJ,MACpCqJ,EAAQrJ,MAAQ,EAEkB,IAArCqJ,EAAQtJ,KAAOuJ,EAAQzX,WAAyD,IAArCyX,EAAQvJ,KAAOsJ,EAAQxX,gBAK/EmT,qBAAqB,GAAGuE,SAAS,EAAEC,QAAQ,KAAKC,GAAG,SAAS1L,EAAQ9uB,EAAOD,GAO9E,GAAI06B,KAEJz6B,GAAOD,QAAU06B,CAEjB,IAAIzB,GAAOlK,EAAQ,UACfgK,EAAWhK,EAAQ,cACnBtB,EAASsB,EAAQ,mBAErB,WAQI2L,EAAK7qB,OAAS,SAASpN,GACnB,GAAIgtB,IACAkL,WAAYD,EACZE,SAAU7B,EAASG,WACnB2B,WACAxB,SACAyB,aACAC,YAAa,GACbC,aAAc,GAGlB,OAAOvN,GAAO9qB,OAAO8sB,EAAUhtB,IA2BnCi4B,EAAKvI,OAAS,SAAS8I,EAAM7O,EAAQsB,EAAQ1f,GACzC,GAAI9N,GAAGg7B,EAAKC,EAGRC,EACAC,EAHApN,EAAQP,EAAOO,MACf4M,EAAUI,EAAKJ,QAGfS,GAAc,CAGlB,KAAKp7B,EAAI,EAAGA,EAAIksB,EAAOlqB,OAAQhC,IAAK,CAChC,GAAIqgB,GAAO6L,EAAOlsB,EAElB,MAAIqgB,EAAKiQ,YAAexiB,MAIpBuS,EAAKsR,OAAOhV,IAAIoP,EAAIgC,EAAM4D,OAAO7oB,IAAIijB,GAAK1L,EAAKsR,OAAO7oB,IAAIijB,EAAIgC,EAAM4D,OAAOhV,IAAIoP,GAC5E1L,EAAKsR,OAAOhV,IAAIqP,EAAI+B,EAAM4D,OAAO7oB,IAAIkjB,GAAK3L,EAAKsR,OAAO7oB,IAAIkjB,EAAI+B,EAAM4D,OAAOhV,IAAIqP,GADtF,CAIA,GAAIqP,GAAYb,EAAKc,WAAWP,EAAM1a,EAGtC,KAAKA,EAAKkb,QAAUF,EAAU7mB,KAAO6L,EAAKkb,OAAO/mB,IAAM1G,EAAa,CAG3DuS,EAAKkb,SAAUztB,IAChBuS,EAAKkb,OAASF,EAElB,IAAIG,GAAQhB,EAAKiB,aAAaJ,EAAWhb,EAAKkb,OAI9C,KAAKP,EAAMQ,EAAME,SAAUV,GAAOQ,EAAMG,OAAQX,IAC5C,IAAKC,EAAMO,EAAMI,SAAUX,GAAOO,EAAMK,OAAQZ,IAAO,CACnDE,EAAWX,EAAKsB,aAAad,EAAKC,GAClCC,EAASP,EAAQQ,EAEjB,IAAIY,GAAqBf,GAAOK,EAAUK,UAAYV,GAAOK,EAAUM,QAC5CV,GAAOI,EAAUO,UAAYX,GAAOI,EAAUQ,OAErEG,EAAqBhB,GAAO3a,EAAKkb,OAAOG,UAAYV,GAAO3a,EAAKkb,OAAOI,QAChDV,GAAO5a,EAAKkb,OAAOK,UAAYX,GAAO5a,EAAKkb,OAAOM,QAGxEE,GAAqBC,GAClBA,GACId,GACAV,EAAKyB,kBAAkBlB,EAAMG,EAAQ7a,IAK7CA,EAAKkb,SAAWF,GAAcU,IAAsBC,GAAsBluB,KACrEotB,IACDA,EAASV,EAAK0B,cAAcvB,EAASQ,IACzCX,EAAK2B,eAAepB,EAAMG,EAAQ7a,IAM9CA,EAAKkb,OAASF,EAGdD,GAAc,IAKlBA,IACAL,EAAKH,UAAYJ,EAAK4B,uBAAuBrB,KAQrDP,EAAK/C,MAAQ,SAASsD,GAClBA,EAAKJ,WACLI,EAAK5B,SACL4B,EAAKH,cAWTJ,EAAKiB,aAAe,SAASY,EAASC,GAClC,GAAIZ,GAAW5kB,KAAKhO,IAAIuzB,EAAQX,SAAUY,EAAQZ,UAC9CC,EAAS7kB,KAAK6F,IAAI0f,EAAQV,OAAQW,EAAQX,QAC1CC,EAAW9kB,KAAKhO,IAAIuzB,EAAQT,SAAUU,EAAQV,UAC9CC,EAAS/kB,KAAK6F,IAAI0f,EAAQR,OAAQS,EAAQT,OAE9C,OAAOrB,GAAK+B,cAAcb,EAAUC,EAAQC,EAAUC,IAW1DrB,EAAKc,WAAa,SAASP,EAAM1a,GAC7B,GAAIsR,GAAStR,EAAKsR,OACd+J,EAAW5kB,KAAK0lB,MAAM7K,EAAO7oB,IAAIijB,EAAIgP,EAAKF,aAC1Cc,EAAS7kB,KAAK0lB,MAAM7K,EAAOhV,IAAIoP,EAAIgP,EAAKF,aACxCe,EAAW9kB,KAAK0lB,MAAM7K,EAAO7oB,IAAIkjB,EAAI+O,EAAKD,cAC1Ce,EAAS/kB,KAAK0lB,MAAM7K,EAAOhV,IAAIqP,EAAI+O,EAAKD,aAE5C,OAAON,GAAK+B,cAAcb,EAAUC,EAAQC,EAAUC,IAa1DrB,EAAK+B,cAAgB,SAASb,EAAUC,EAAQC,EAAUC,GACtD,OACIrnB,GAAIknB,EAAW,IAAMC,EAAS,IAAMC,EAAW,IAAMC,EACrDH,SAAUA,EACVC,OAAQA,EACRC,SAAUA,EACVC,OAAQA,IAYhBrB,EAAKsB,aAAe,SAAS7W,EAAQgW,GACjC,MAAO,IAAMhW,EAAS,IAAMgW,GAWhCT,EAAK0B,cAAgB,SAASvB,EAASQ,GAEnC,MADaR,GAAQQ,OAYzBX,EAAK2B,eAAiB,SAASpB,EAAMG,EAAQ7a,GAEzC,IAAK,GAAIrgB,GAAI,EAAGA,EAAIk7B,EAAOl5B,OAAQhC,IAAK,CACpC,GAAIs5B,GAAQ4B,EAAOl7B,EAEnB,MAAIqgB,EAAK7L,KAAO8kB,EAAM9kB,IAAO6L,EAAKkO,UAAY+K,EAAM/K,UAApD,CAKA,GAAIsL,GAASd,EAAKvkB,GAAG6L,EAAMiZ,GACvBQ,EAAOiB,EAAK5B,MAAMU,EAElBC,GACAA,EAAK,IAAM,EAEXiB,EAAK5B,MAAMU,IAAWxZ,EAAMiZ,EAAO,IAK3C4B,EAAOh5B,KAAKme,IAWhBma,EAAKyB,kBAAoB,SAASlB,EAAMG,EAAQ7a,GAE5C6a,EAAO1wB,OAAO+iB,EAAOrW,QAAQgkB,EAAQ7a,GAAO,EAG5C,KAAK,GAAIrgB,GAAI,EAAGA,EAAIk7B,EAAOl5B,OAAQhC,IAAK,CAGpC,GAAIs5B,GAAQ4B,EAAOl7B,GACf65B,EAASd,EAAKvkB,GAAG6L,EAAMiZ,GACvBQ,EAAOiB,EAAK5B,MAAMU,EAElBC,KACAA,EAAK,IAAM,KAWvBU,EAAK4B,uBAAyB,SAASrB,GACnC,GAAI0B,GACA3C,EACAX,IAGJsD,GAAWlP,EAAOmP,KAAK3B,EAAK5B,MAG5B,KAAK,GAAIO,GAAI,EAAGA,EAAI+C,EAASz6B,OAAQ03B,IACjCI,EAAOiB,EAAK5B,MAAMsD,EAAS/C,IAIvBI,EAAK,GAAK,EACVX,EAAMj3B,KAAK43B,SAEJiB,GAAK5B,MAAMsD,EAAS/C,GAInC,OAAOP,SAKZxD,iBAAiB,GAAGgH,aAAa,EAAEtC,SAAS,IAAIuC,GAAG,SAAS/N,EAAQ9uB,EAAOD,GAO9E,GAAIi5B,KAEJh5B,GAAOD,QAAUi5B,CAEjB,IAAIP,GAAU3J,EAAQ,cAEtB,WASIkK,EAAKppB,OAAS,SAASqqB,EAAW6C,GAC9B,GAAIxD,GAAQW,EAAUX,MAClBC,EAAQU,EAAUV,MAClBwD,EAAU9C,EAAU8C,QACpBC,EAAU/C,EAAU+C,QAEpBjD,GACAtlB,GAAIukB,EAAKvkB,GAAG6kB,EAAOC,GACnBD,MAAOA,EACPC,MAAOA,EACP0D,YACAC,kBACAC,WAAY,EACZnD,UAAU,EACV1J,SAAUgJ,EAAMhJ,UAAYiJ,EAAMjJ,SAClC8M,YAAaN,EACbO,YAAaP,EACb3J,YAAa4J,EAAQ5J,YAAc6J,EAAQ7J,YAC3CpG,SAAUhW,KAAKhO,IAAIg0B,EAAQhQ,SAAUiQ,EAAQjQ,UAC7C6D,eAAgB7Z,KAAK6F,IAAImgB,EAAQnM,eAAgBoM,EAAQpM,gBACzDD,YAAa5Z,KAAK6F,IAAImgB,EAAQpM,YAAaqM,EAAQrM,aACnDK,KAAMja,KAAK6F,IAAImgB,EAAQ/L,KAAMgM,EAAQhM,MAKzC,OAFAgI,GAAK9G,OAAO6H,EAAME,EAAW6C,GAEtB/C,GAUXf,EAAK9G,OAAS,SAAS6H,EAAME,EAAW6C,GACpC,GAAIG,GAAWlD,EAAKkD,SAChBK,EAAWrD,EAAUqD,SACrBJ,EAAiBnD,EAAKmD,eACtBH,EAAU9C,EAAU8C,QACpBC,EAAU/C,EAAU+C,OAUxB,IARAjD,EAAKE,UAAYA,EACjBF,EAAK5G,YAAc4J,EAAQ5J,YAAc6J,EAAQ7J,YACjD4G,EAAKhN,SAAWhW,KAAKhO,IAAIg0B,EAAQhQ,SAAUiQ,EAAQjQ,UACnDgN,EAAKnJ,eAAiB7Z,KAAK6F,IAAImgB,EAAQnM,eAAgBoM,EAAQpM,gBAC/DmJ,EAAKpJ,YAAc5Z,KAAK6F,IAAImgB,EAAQpM,YAAaqM,EAAQrM,aACzDoJ,EAAK/I,KAAOja,KAAK6F,IAAImgB,EAAQ/L,KAAMgM,EAAQhM,MAC3CkM,EAAej7B,OAAS,EAEpBg4B,EAAUE,SAAU,CACpB,IAAK,GAAIl6B,GAAI,EAAGA,EAAIq9B,EAASr7B,OAAQhC,IAAK,CACtC,GAAIs9B,GAAUD,EAASr9B,GACnBu9B,EAAY/E,EAAQhkB,GAAG8oB,GACvBE,EAAUR,EAASO,EAEnBC,GACAP,EAAe/6B,KAAKs7B,GAEpBP,EAAe/6B,KAAK86B,EAASO,GAAa/E,EAAQ7oB,OAAO2tB,IAIjExD,EAAKoD,WAAalD,EAAUyD,MAC5B1E,EAAK2E,UAAU5D,GAAM,EAAM+C,QAEL,IAAlB/C,EAAKC,UACLhB,EAAK2E,UAAU5D,GAAM,EAAO+C,IAWxC9D,EAAK2E,UAAY,SAAS5D,EAAMC,EAAU8C,GAClC9C,GACAD,EAAKC,UAAW,EAChBD,EAAKsD,YAAcP,IAEnB/C,EAAKC,UAAW,EAChBD,EAAKmD,eAAej7B,OAAS,IAWrC+2B,EAAKvkB,GAAK,SAAS6kB,EAAOC,GACtB,MAAID,GAAM7kB,GAAK8kB,EAAM9kB,GACV,IAAM6kB,EAAM7kB,GAAK,IAAM8kB,EAAM9kB,GAE7B,IAAM8kB,EAAM9kB,GAAK,IAAM6kB,EAAM7kB,SAM7CmpB,YAAY,IAAIC,GAAG,SAAS/O,EAAQ9uB,EAAOD,GAO9C,GAAI+9B,KAEJ99B,GAAOD,QAAU+9B,CAEjB,IAAI9E,GAAOlK,EAAQ,UACftB,EAASsB,EAAQ,mBAErB,WAEIgP,EAAMC,iBAAmB,IAQzBD,EAAMluB,OAAS,SAASpN,GACpB,MAAOgrB,GAAO9qB,QACV22B,SACA/1B,QACA06B,kBACAC,mBACAC,iBACD17B,IAUPs7B,EAAM5L,OAAS,SAASkH,EAAOH,EAAY6D,GACvC,GAMI7C,GACAH,EACAC,EACA95B,EATA46B,EAAYzB,EAAM91B,KAClB61B,EAAaC,EAAMC,MACnB2E,EAAiB5E,EAAM4E,eACvBE,EAAe9E,EAAM8E,aACrBD,EAAkB7E,EAAM6E,gBACxBE,IAWJ,KAJAH,EAAe/7B,OAAS,EACxBi8B,EAAaj8B,OAAS,EACtBg8B,EAAgBh8B,OAAS,EAEpBhC,EAAI,EAAGA,EAAIg5B,EAAWh3B,OAAQhC,IAC/Bg6B,EAAYhB,EAAWh5B,GAEnBg6B,EAAUE,WACVL,EAASd,EAAKvkB,GAAGwlB,EAAUX,MAAOW,EAAUV,OAC5C4E,EAAch8B,KAAK23B,GAEnBC,EAAOZ,EAAWW,GAEdC,GAEIA,EAAKC,SAELiE,EAAgB97B,KAAK43B,GAGrBiE,EAAe77B,KAAK43B,GAIxBf,EAAK9G,OAAO6H,EAAME,EAAW6C,KAG7B/C,EAAOf,EAAKppB,OAAOqqB,EAAW6C,GAC9B3D,EAAWW,GAAUC,EAGrBiE,EAAe77B,KAAK43B,GACpBc,EAAU14B,KAAK43B,IAM3B,KAAK95B,EAAI,EAAGA,EAAI46B,EAAU54B,OAAQhC,IAC9B85B,EAAOc,EAAU56B,GACb85B,EAAKC,WAAwD,IAA5CxM,EAAOrW,QAAQgnB,EAAepE,EAAKtlB,MACpDukB,EAAK2E,UAAU5D,GAAM,EAAO+C,GAC5BoB,EAAa/7B,KAAK43B,KAW9B+D,EAAMM,UAAY,SAAShF,EAAO0D,GAC9B,GAGI/C,GACAE,EACAoE,EACAp+B,EANA46B,EAAYzB,EAAM91B,KAClB61B,EAAaC,EAAMC,MACnBiF,IAMJ,KAAKr+B,EAAI,EAAGA,EAAI46B,EAAU54B,OAAQhC,IAC9B85B,EAAOc,EAAU56B,GACjBg6B,EAAYF,EAAKE,UAGbA,EAAUX,MAAM/I,YAAc0J,EAAUV,MAAMhJ,WAC9CwJ,EAAKsD,YAAcP,EAKnBA,EAAY/C,EAAKsD,YAAcS,EAAMC,kBACrCO,EAAgBn8B,KAAKlC,EAK7B,KAAKA,EAAI,EAAGA,EAAIq+B,EAAgBr8B,OAAQhC,IACpCo+B,EAAYC,EAAgBr+B,GAAKA,EACjC85B,EAAOc,EAAUwD,SACVlF,GAAWY,EAAKtlB,IACvBomB,EAAUpwB,OAAO4zB,EAAW,IAUpCP,EAAMpG,MAAQ,SAAS0B,GAMnB,MALAA,GAAMC,SACND,EAAM91B,KAAKrB,OAAS,EACpBm3B,EAAM4E,eAAe/7B,OAAS,EAC9Bm3B,EAAM6E,gBAAgBh8B,OAAS,EAC/Bm3B,EAAM8E,aAAaj8B,OAAS,EACrBm3B,QAKZxD,iBAAiB,GAAG0E,SAAS,IAAIiE,GAAG,SAASzP,EAAQ9uB,EAAOD,GAS/D,GAAIy+B,KAEJx+B,GAAOD,QAAUy+B,CAEjB,IAAIxP,GAASF,EAAQ,sBACjBiK,EAAMjK,EAAQ,SACdI,EAASJ,EAAQ,sBACjBjC,EAASiC,EAAQ,qBACjBC,EAAWD,EAAQ,yBAEvB,WASI0P,EAAMtE,SAAW,SAAS5Z,EAAM6L,GAG5B,IAAK,GAFD8M,MAEKh5B,EAAI,EAAGA,EAAIksB,EAAOlqB,OAAQhC,IAAK,CACpC,GAAIq5B,GAAQnN,EAAOlsB,EAEnB,IAAIivB,EAAOuK,SAASH,EAAM1H,OAAQtR,EAAKsR,QACnC,IAAK,GAAIppB,GAA2B,IAAvB8wB,EAAM1a,MAAM3c,OAAe,EAAI,EAAGuG,EAAI8wB,EAAM1a,MAAM3c,OAAQuG,IAAK,CACxE,GAAIyqB,GAAOqG,EAAM1a,MAAMpW,EAEvB,IAAI0mB,EAAOuK,SAASxG,EAAKrB,OAAQtR,EAAKsR,QAAS,CAC3C,GAAIqI,GAAYlB,EAAImB,SAASjH,EAAM3S,EAEnC,IAAI2Z,EAAUE,SAAU,CACpBlB,EAAW92B,KAAK83B,EAChB,UAOpB,MAAOhB,IAYXuF,EAAMC,IAAM,SAAStS,EAAQuS,EAAYC,EAAUC,GAC/CA,EAAWA,GAAY,MASvB,KAAK,GAPDC,GAAW7P,EAAO/B,MAAMyR,EAAYC,GACpCG,EAAY9P,EAAOmF,UAAUnF,EAAOiF,IAAIyK,EAAYC,IACpDI,EAAqC,IAA7BJ,EAAS3S,EAAI0S,EAAW1S,GAChCgT,EAAqC,IAA7BL,EAAS1S,EAAIyS,EAAWzS,GAChCwS,EAAM5R,EAAOC,UAAUiS,EAAMC,EAAMF,EAAWF,GAAY3R,MAAO4R,IACjE5F,EAAauF,EAAMtE,SAASuE,EAAKtS,GAE5BlsB,EAAI,EAAGA,EAAIg5B,EAAWh3B,OAAQhC,GAAK,EAAG,CAC3C,GAAIg6B,GAAYhB,EAAWh5B,EAC3Bg6B,GAAU3Z,KAAO2Z,EAAUV,MAAQU,EAAUX,MAGjD,MAAOL,IAWXuF,EAAMhD,OAAS,SAASrP,EAAQyF,EAAQqN,GAGpC,IAAK,GAFDC,MAEKj/B,EAAI,EAAGA,EAAIksB,EAAOlqB,OAAQhC,IAAK,CACpC,GAAIqgB,GAAO6L,EAAOlsB,GACdw5B,EAAWvK,EAAOuK,SAASnZ,EAAKsR,OAAQA,IACvC6H,IAAawF,IAAcxF,GAAYwF,IACxCC,EAAO/8B,KAAKme,GAGpB,MAAO4e,IAUXV,EAAMjK,MAAQ,SAASpI,EAAQoI,GAG3B,IAAK,GAFD2K,MAEKj/B,EAAI,EAAGA,EAAIksB,EAAOlqB,OAAQhC,IAAK,CACpC,GAAIqgB,GAAO6L,EAAOlsB,EAElB,IAAIivB,EAAOiQ,SAAS7e,EAAKsR,OAAQ2C,GAC7B,IAAK,GAAI/rB,GAA0B,IAAtB8X,EAAK1B,MAAM3c,OAAe,EAAI,EAAGuG,EAAI8X,EAAK1B,MAAM3c,OAAQuG,IAAK,CACtE,GAAIyqB,GAAO3S,EAAK1B,MAAMpW,EAEtB,IAAI0mB,EAAOiQ,SAASlM,EAAKrB,OAAQ2C,IAC1BxF,EAASoQ,SAASlM,EAAKtD,SAAU4E,GAAQ,CAC5C2K,EAAO/8B,KAAKme,EACZ,SAMhB,MAAO4e,SAKZE,oBAAoB,GAAGrJ,qBAAqB,GAAGC,qBAAqB,GAAGC,uBAAuB,GAAGsE,QAAQ,KAAK8E,IAAI,SAASvQ,EAAQ9uB,EAAOD,GAO7I,GAAIu/B,KAEJt/B,GAAOD,QAAUu/B,CAEjB,IAAIvQ,GAAWD,EAAQ,wBACnBE,EAASF,EAAQ,sBACjBtB,EAASsB,EAAQ,kBACjBI,EAASJ,EAAQ,uBAErB,WAEIwQ,EAASC,eAAiB,EAC1BD,EAASE,sBAAwB,EACjCF,EAASG,gBAAkB,GAC3BH,EAASI,iBAAmB,GAC5BJ,EAASK,0BAA4B,EAOrCL,EAASM,iBAAmB,SAASxG,GACjC,GAAIn5B,GACA85B,EACA8F,CAGJ,KAAK5/B,EAAI,EAAGA,EAAIm5B,EAAMn3B,OAAQhC,IAC1B85B,EAAOX,EAAMn5B,GAER85B,EAAKC,WAGV6F,EAAc9F,EAAKmD,eAAej7B,OAClC83B,EAAKE,UAAU8C,QAAQ9M,eAAiB4P,EACxC9F,EAAKE,UAAU+C,QAAQ/M,eAAiB4P,IAUhDP,EAASQ,cAAgB,SAAS1G,EAAOnI,GACrC,GAAIhxB,GACA85B,EACAE,EACAX,EACAC,EACAwG,EACAC,EACAC,EACAlQ,EAEAmQ,EAAQlR,EAAO1e,MAAM,GACrB6vB,EAAQnR,EAAO1e,MAAM,GACrB8vB,EAAQpR,EAAO1e,MAAM,GACrB+vB,EAAQrR,EAAO1e,MAAM,EAGzB,KAAKrQ,EAAI,EAAGA,EAAIm5B,EAAMn3B,OAAQhC,IAC1B85B,EAAOX,EAAMn5B,GAER85B,EAAKC,WAAYD,EAAKzJ,WAG3B2J,EAAYF,EAAKE,UACjBX,EAAQW,EAAU8C,QAClBxD,EAAQU,EAAU+C,QAClB+C,EAAS9F,EAAU8F,OAGnBC,EAAWhR,EAAOiF,IAAIjF,EAAOpC,IAAI2M,EAAMxJ,gBAAiBwJ,EAAMnL,SAAU8R,GAChDlR,EAAOpC,IAAI0M,EAAMvJ,gBACbf,EAAOiF,IAAIsF,EAAMnL,SAAU6L,EAAUqG,YAAaH,GAAQC,GAAQC,GAE9FtG,EAAKoD,WAAanO,EAAOuR,IAAIR,EAAQC,GAGzC,KAAK//B,EAAI,EAAGA,EAAIm5B,EAAMn3B,OAAQhC,IAC1B85B,EAAOX,EAAMn5B,GAER85B,EAAKC,WAAYD,EAAKzJ,WAG3B2J,EAAYF,EAAKE,UACjBX,EAAQW,EAAU8C,QAClBxD,EAAQU,EAAU+C,QAClB+C,EAAS9F,EAAU8F,OACnBhQ,GAAmBgK,EAAKoD,WAAapD,EAAK/I,MAAQC,GAE9CqI,EAAM9K,UAAY+K,EAAM/K,YACxBuB,GAAmB,GAEjBuJ,EAAM9K,UAAY8K,EAAM/I,aAC1B0P,EAAeX,EAASG,gBAAkBnG,EAAMrJ,cAChDqJ,EAAMvJ,gBAAgB/D,GAAK+T,EAAO/T,EAAI+D,EAAkBkQ,EACxD3G,EAAMvJ,gBAAgB9D,GAAK8T,EAAO9T,EAAI8D,EAAkBkQ,GAGtD1G,EAAM/K,UAAY+K,EAAMhJ,aAC1B0P,EAAeX,EAASG,gBAAkBlG,EAAMtJ,cAChDsJ,EAAMxJ,gBAAgB/D,GAAK+T,EAAO/T,EAAI+D,EAAkBkQ,EACxD1G,EAAMxJ,gBAAgB9D,GAAK8T,EAAO9T,EAAI8D,EAAkBkQ,KAUpEX,EAASkB,kBAAoB,SAASrU,GAClC,IAAK,GAAIlsB,GAAI,EAAGA,EAAIksB,EAAOlqB,OAAQhC,IAAK,CACpC,GAAIqgB,GAAO6L,EAAOlsB,EAKlB,IAFAqgB,EAAK2P,cAAgB,EAEU,IAA3B3P,EAAKyP,gBAAgB/D,GAAsC,IAA3B1L,EAAKyP,gBAAgB9D,EAAS,CAE9D,IAAK,GAAIzjB,GAAI,EAAGA,EAAI8X,EAAK1B,MAAM3c,OAAQuG,IAAK,CACxC,GAAIyqB,GAAO3S,EAAK1B,MAAMpW,EACtBumB,GAAS0E,UAAUR,EAAKtD,SAAUrP,EAAKyP,iBACvCb,EAAOgD,OAAOe,EAAKrB,OAAQqB,EAAKtD,SAAUrP,EAAK8P,UAC/C6C,EAAK7E,SAASpC,GAAK1L,EAAKyP,gBAAgB/D,EACxCiH,EAAK7E,SAASnC,GAAK3L,EAAKyP,gBAAgB9D,EAI5C3L,EAAKuR,aAAa7F,GAAK1L,EAAKyP,gBAAgB/D,EAC5C1L,EAAKuR,aAAa5F,GAAK3L,EAAKyP,gBAAgB9D,EAExC+C,EAAOuR,IAAIjgB,EAAKyP,gBAAiBzP,EAAK8P,UAAY,GAElD9P,EAAKyP,gBAAgB/D,EAAI,EACzB1L,EAAKyP,gBAAgB9D,EAAI,IAGzB3L,EAAKyP,gBAAgB/D,GAAKsT,EAASI,iBACnCpf,EAAKyP,gBAAgB9D,GAAKqT,EAASI,qBAWnDJ,EAASmB,iBAAmB,SAASrH,GACjC,GAAIn5B,GACAuI,EACAuxB,EACAkD,EACAhD,EACAX,EACAC,EACAwG,EACAW,EACAjD,EACAkD,EACAhI,EACAC,EACApD,EACAoL,EAAU5R,EAAO1e,MAAM,GACvB4vB,EAAQlR,EAAO1e,MAAM,EAEzB,KAAKrQ,EAAI,EAAGA,EAAIm5B,EAAMn3B,OAAQhC,IAG1B,GAFA85B,EAAOX,EAAMn5B,GAER85B,EAAKC,WAAYD,EAAKzJ,SAW3B,IARA2M,EAAWlD,EAAKmD,eAChBjD,EAAYF,EAAKE,UACjBX,EAAQW,EAAU8C,QAClBxD,EAAQU,EAAU+C,QAClB+C,EAAS9F,EAAU8F,OACnBW,EAAUzG,EAAUyG,QAGfl4B,EAAI,EAAGA,EAAIy0B,EAASh7B,OAAQuG,IAC7Bi1B,EAAUR,EAASz0B,GACnBm4B,EAAgBlD,EAAQ/E,OACxBC,EAAgB8E,EAAQ9E,cACxBC,EAAiB6E,EAAQ7E,eAEH,IAAlBD,GAA0C,IAAnBC,IAEvBgI,EAAQ5U,EAAK+T,EAAO/T,EAAI2M,EAAkB+H,EAAQ1U,EAAI4M,EACtDgI,EAAQ3U,EAAK8T,EAAO9T,EAAI0M,EAAkB+H,EAAQzU,EAAI2M,EAGhDU,EAAM9K,UAAY8K,EAAM/I,aAC1BiF,EAASxG,EAAOiF,IAAI0M,EAAerH,EAAMlL,SAAU8R,GACnD5G,EAAMzH,aAAa7F,GAAK4U,EAAQ5U,EAAIsN,EAAMnG,YAC1CmG,EAAMzH,aAAa5F,GAAK2U,EAAQ3U,EAAIqN,EAAMnG,YAC1CmG,EAAMvH,WAAa/C,EAAO6R,MAAMrL,EAAQoL,GAAWtH,EAAMlG,gBAGvDmG,EAAM/K,UAAY+K,EAAMhJ,aAC1BiF,EAASxG,EAAOiF,IAAI0M,EAAepH,EAAMnL,SAAU8R,GACnD3G,EAAM1H,aAAa7F,GAAK4U,EAAQ5U,EAAIuN,EAAMpG,YAC1CoG,EAAM1H,aAAa5F,GAAK2U,EAAQ3U,EAAIsN,EAAMpG,YAC1CoG,EAAMxH,WAAa/C,EAAO6R,MAAMrL,EAAQoL,GAAWrH,EAAMnG,kBAa7EkM,EAASwB,cAAgB,SAAS1H,EAAOnI,GASrC,IAAK,GARD8P,GAAmB9P,EAAYA,EAC/B2P,EAAU5R,EAAO1e,MAAM,GACvB4vB,EAAQlR,EAAO1e,MAAM,GACrB6vB,EAAQnR,EAAO1e,MAAM,GACrB8vB,EAAQpR,EAAO1e,MAAM,GACrB+vB,EAAQrR,EAAO1e,MAAM,GACrB0wB,EAAQhS,EAAO1e,MAAM,GAEhBrQ,EAAI,EAAGA,EAAIm5B,EAAMn3B,OAAQhC,IAAK,CACnC,GAAI85B,GAAOX,EAAMn5B,EAEjB,IAAK85B,EAAKC,WAAYD,EAAKzJ,SAA3B,CAGA,GAAI2J,GAAYF,EAAKE,UACjBX,EAAQW,EAAU8C,QAClBxD,EAAQU,EAAU+C,QAClB+C,EAAS9F,EAAU8F,OACnBW,EAAUzG,EAAUyG,QACpBzD,EAAWlD,EAAKmD,eAChB+C,EAAe,EAAIhD,EAASh7B,MAGhCq3B,GAAMlJ,SAASpE,EAAIsN,EAAMlL,SAASpC,EAAIsN,EAAMzH,aAAa7F,EACzDsN,EAAMlJ,SAASnE,EAAIqN,EAAMlL,SAASnC,EAAIqN,EAAMzH,aAAa5F,EACzDsN,EAAMnJ,SAASpE,EAAIuN,EAAMnL,SAASpC,EAAIuN,EAAM1H,aAAa7F,EACzDuN,EAAMnJ,SAASnE,EAAIsN,EAAMnL,SAASnC,EAAIsN,EAAM1H,aAAa5F,EACzDqN,EAAMjJ,gBAAkBiJ,EAAMrM,MAAQqM,EAAMvH,UAC5CwH,EAAMlJ,gBAAkBkJ,EAAMtM,MAAQsM,EAAMxH,SAG5C,KAAK,GAAIvpB,GAAI,EAAGA,EAAIy0B,EAASh7B,OAAQuG,IAAK,CACtC,GAAIi1B,GAAUR,EAASz0B,GACnBm4B,EAAgBlD,EAAQ/E,OACxBuI,EAAUjS,EAAOiF,IAAI0M,EAAerH,EAAMlL,SAAU8R,GACpDgB,EAAUlS,EAAOiF,IAAI0M,EAAepH,EAAMnL,SAAU+R,GACpDgB,EAAiBnS,EAAOpC,IAAI0M,EAAMlJ,SAAUpB,EAAO0G,KAAK1G,EAAOoS,KAAKH,GAAU3H,EAAMjJ,iBAAkB+P,GACtGiB,EAAiBrS,EAAOpC,IAAI2M,EAAMnJ,SAAUpB,EAAO0G,KAAK1G,EAAOoS,KAAKF,GAAU3H,EAAMlJ,iBAAkBgQ,GACtGiB,EAAmBtS,EAAOiF,IAAIkN,EAAgBE,EAAgBL,GAC9DO,EAAiBvS,EAAOuR,IAAIR,EAAQuB,GAEpCE,EAAkBxS,EAAOuR,IAAIG,EAASY,GACtCG,EAAe1qB,KAAKqd,IAAIoN,GACxBE,EAA2BlU,EAAOmU,KAAKH,GAGvC7I,GAAiB,EAAIoB,EAAKpJ,aAAe4Q,EACzCK,EAAcpU,EAAOqU,MAAM9H,EAAKoD,WAAaoE,EAAgB,EAAG,GAAKjC,EAASK,0BAG9E/G,EAAiB4I,EACjBM,EAAczO,GAEdoO,GAAe1H,EAAKhN,SAAWgN,EAAKnJ,eAAiBgR,EAAcb,IACnEe,EAAcL,EACd7I,EAAiBpL,EAAOqU,MACpB9H,EAAKhN,SAAW2U,EAA2BX,GAC1Ce,EAAaA,GAKtB,IAAIC,GAAO/S,EAAO6R,MAAMI,EAASlB,GAC7BiC,EAAOhT,EAAO6R,MAAMK,EAASnB,GAC7BkC,EAAQhC,GAAgB3G,EAAMnG,YAAcoG,EAAMpG,YAAcmG,EAAMlG,eAAiB2O,EAAOA,EAAQxI,EAAMnG,eAAiB4O,EAAOA,EAMxI,IAJArJ,GAAiBsJ,EACjBrJ,GAAkBqJ,EAGdV,EAAiB,GAAKA,EAAiBA,EAAiBjC,EAASC,eAAiBwB,EAElFtD,EAAQ9E,cAAgB,MACrB,CAGH,GAAIuJ,GAAuBzE,EAAQ9E,aACnC8E,GAAQ9E,cAAgB5hB,KAAKhO,IAAI00B,EAAQ9E,cAAgBA,EAAe,GACxEA,EAAgB8E,EAAQ9E,cAAgBuJ,EAI5C,GAAIV,EAAkBA,EAAkBlC,EAASE,sBAAwBuB,EAErEtD,EAAQ7E,eAAiB,MACtB,CAGH,GAAIuJ,GAAwB1E,EAAQ7E,cACpC6E,GAAQ7E,eAAiBpL,EAAOqU,MAAMpE,EAAQ7E,eAAiBA,GAAiBkJ,EAAaA,GAC7FlJ,EAAiB6E,EAAQ7E,eAAiBuJ,EAI9CvB,EAAQ5U,EAAK+T,EAAO/T,EAAI2M,EAAkB+H,EAAQ1U,EAAI4M,EACtDgI,EAAQ3U,EAAK8T,EAAO9T,EAAI0M,EAAkB+H,EAAQzU,EAAI2M,EAGhDU,EAAM9K,UAAY8K,EAAM/I,aAC1B+I,EAAMzH,aAAa7F,GAAK4U,EAAQ5U,EAAIsN,EAAMnG,YAC1CmG,EAAMzH,aAAa5F,GAAK2U,EAAQ3U,EAAIqN,EAAMnG,YAC1CmG,EAAMvH,WAAa/C,EAAO6R,MAAMI,EAASL,GAAWtH,EAAMlG,gBAGxDmG,EAAM/K,UAAY+K,EAAMhJ,aAC1BgJ,EAAM1H,aAAa7F,GAAK4U,EAAQ5U,EAAIuN,EAAMpG,YAC1CoG,EAAM1H,aAAa5F,GAAK2U,EAAQ3U,EAAIsN,EAAMpG,YAC1CoG,EAAMxH,WAAa/C,EAAO6R,MAAMK,EAASN,GAAWrH,EAAMnG,yBAQ3EwC,iBAAiB,GAAGG,qBAAqB,GAAGC,qBAAqB,GAAGC,uBAAuB,KAAKmM,IAAI,SAAStT,EAAQ9uB,EAAOD,GAS/H,GAAIg5B,KAEJ/4B,GAAOD,QAAUg5B,CAEjB,IAAIhK,GAAWD,EAAQ,wBACnBE,EAASF,EAAQ,uBAErB,WAUIiK,EAAImB,SAAW,SAASZ,EAAOC,EAAOM,GAClC,GAAIwI,GACAC,EACAC,EACAtI,EACAuI,GAAkB,CAEtB,IAAI3I,EAAmB,CAEnB,GAAIkD,GAAUzD,EAAMxyB,OAChBk2B,EAAUzD,EAAMzyB,OAChB0pB,EAASuM,EAAQ7M,MAAQ6M,EAAQ7M,MAAQ6M,EAAQ5M,aAAe4M,EAAQ5M,aAC/D6M,EAAQ9M,MAAQ8M,EAAQ9M,MAAQ8M,EAAQ7M,aAAe6M,EAAQ7M,YAI5EqS,GAAkB3I,GAAqBA,EAAkBM,UAAY3J,EAAS,GAG9EyJ,EAAYJ,MAEZI,IAAcE,UAAU,EAAOb,MAAOA,EAAOC,MAAOA,EAGxD,IAAIM,GAAqB2I,EAAiB,CAGtC,GAAIC,GAAYxI,EAAUyI,SACtBC,EAAYF,IAAcnJ,EAAQC,EAAQD,EAC1CrH,GAAQwQ,EAAUxQ,KAAK4H,EAAkB+I,YAK7C,IAHAL,EAAaxJ,EAAI8J,aAAaJ,EAAU9S,SAAUgT,EAAUhT,SAAUsC,GACtEgI,EAAU6I,QAAS,EAEfP,EAAWQ,SAAW,EAEtB,MADA9I,GAAUE,UAAW,EACdF,MAER,CAKH,GAFAoI,EAAYtJ,EAAI8J,aAAavJ,EAAM3J,SAAU4J,EAAM5J,SAAU2J,EAAMrH,MAE/DoQ,EAAUU,SAAW,EAErB,MADA9I,GAAUE,UAAW,EACdF,CAKX,IAFAqI,EAAYvJ,EAAI8J,aAAatJ,EAAM5J,SAAU2J,EAAM3J,SAAU4J,EAAMtH,MAE/DqQ,EAAUS,SAAW,EAErB,MADA9I,GAAUE,UAAW,EACdF,CAGPoI,GAAUU,QAAUT,EAAUS,SAC9BR,EAAaF,EACbpI,EAAUyI,SAAWpJ,IAErBiJ,EAAaD,EACbrI,EAAUyI,SAAWnJ,GAIzBU,EAAU2I,WAAaL,EAAWK,WAGtC3I,EAAUX,MAAQA,EAAM7kB,GAAK8kB,EAAM9kB,GAAK6kB,EAAQC,EAChDU,EAAUV,MAAQD,EAAM7kB,GAAK8kB,EAAM9kB,GAAK8kB,EAAQD,EAChDW,EAAUE,UAAW,EACrBF,EAAUyD,MAAQ6E,EAAWQ,QAC7B9I,EAAU8C,QAAU9C,EAAUX,MAAMxyB,OACpCmzB,EAAU+C,QAAU/C,EAAUV,MAAMzyB,OAEpCwyB,EAAQW,EAAUX,MAClBC,EAAQU,EAAUV,MAGdvK,EAAOuR,IAAIgC,EAAWS,KAAMhU,EAAOiF,IAAIsF,EAAMnL,SAAUkL,EAAMlL,WAAa,EAC1E6L,EAAU8F,QACN/T,EAAGuW,EAAWS,KAAKhX,EACnBC,EAAGsW,EAAWS,KAAK/W,GAGvBgO,EAAU8F,QACN/T,GAAIuW,EAAWS,KAAKhX,EACpBC,GAAIsW,EAAWS,KAAK/W,GAI5BgO,EAAUyG,QAAU1R,EAAOoS,KAAKnH,EAAU8F,QAE1C9F,EAAUqG,YAAcrG,EAAUqG,gBAClCrG,EAAUqG,YAAYtU,EAAIiO,EAAU8F,OAAO/T,EAAIiO,EAAUyD,MACzDzD,EAAUqG,YAAYrU,EAAIgO,EAAU8F,OAAO9T,EAAIgO,EAAUyD,KAGzD,IAAIuF,GAAYlK,EAAImK,cAAc5J,EAAOC,EAAOU,EAAU8F,QACtDzC,IAUJ,IAPIvO,EAASoQ,SAAS7F,EAAM3J,SAAUsT,EAAU,KAC5C3F,EAASn7B,KAAK8gC,EAAU,IAExBlU,EAASoQ,SAAS7F,EAAM3J,SAAUsT,EAAU,KAC5C3F,EAASn7B,KAAK8gC,EAAU,IAGxB3F,EAASr7B,OAAS,EAAG,CACrB,GAAIkhC,GAAYpK,EAAImK,cAAc3J,EAAOD,EAAOtK,EAAOoU,IAAInJ,EAAU8F,QAEjEhR,GAASoQ,SAAS5F,EAAM5J,SAAUwT,EAAU,KAC5C7F,EAASn7B,KAAKghC,EAAU,IAExB7F,EAASr7B,OAAS,GAAK8sB,EAASoQ,SAAS5F,EAAM5J,SAAUwT,EAAU,KACnE7F,EAASn7B,KAAKghC,EAAU,IAShC,MALI7F,GAASr7B,OAAS,IAClBq7B,GAAY2F,EAAU,KAE1BhJ,EAAUqD,SAAWA,EAEdrD,GAYXlB,EAAI8J,aAAe,SAASM,EAAWF,EAAWhR,GAO9C,IAAK,GAHD8Q,GACAC,EAJAK,EAAcrU,EAAO1e,MAAM,GAC3BgzB,EAActU,EAAO1e,MAAM,GAC3B4uB,GAAW6D,QAASQ,OAAOC,WAItBvjC,EAAI,EAAGA,EAAIgyB,EAAKhwB,OAAQhC,IAAK,CAQlC,GAPA+iC,EAAO/Q,EAAKhyB,GAEZ84B,EAAI0K,eAAeJ,EAAaF,EAAWH,GAC3CjK,EAAI0K,eAAeH,EAAaL,EAAWD,IAE3CD,EAAUhsB,KAAKhO,IAAIs6B,EAAYzmB,IAAM0mB,EAAYv6B,IAAKu6B,EAAY1mB,IAAMymB,EAAYt6B,OAErE,EAEX,MADAm2B,GAAO6D,QAAUA,EACV7D,CAGP6D,GAAU7D,EAAO6D,UACjB7D,EAAO6D,QAAUA,EACjB7D,EAAO8D,KAAOA,EACd9D,EAAO0D,WAAa3iC,GAI5B,MAAOi/B,IAWXnG,EAAI0K,eAAiB,SAASC,EAAY/T,EAAUqT,GAIhD,IAAK,GAHDj6B,GAAMimB,EAAOuR,IAAI5Q,EAAS,GAAIqT,GAC9BpmB,EAAM7T,EAED9I,EAAI,EAAGA,EAAI0vB,EAAS1tB,OAAQhC,GAAK,EAAG,CACzC,GAAIsgC,GAAMvR,EAAOuR,IAAI5Q,EAAS1vB,GAAI+iC,EAE9BzC,GAAM3jB,EACNA,EAAM2jB,EACCA,EAAMx3B,IACbA,EAAMw3B,GAIdmD,EAAW36B,IAAMA,EACjB26B,EAAW9mB,IAAMA,GAYrBmc,EAAImK,cAAgB,SAAS5J,EAAOC,EAAOwG,GAWvC,IAAK,GAND4D,GACAjL,EACAkL,EACAC,EAPAC,EAAkBP,OAAOC,UACzBO,EAAe/U,EAAO1e,MAAM,GAC5Bqf,EAAW4J,EAAM5J,SACjBqU,EAAgB1K,EAAMlL,SAOjBnuB,EAAI,EAAGA,EAAI0vB,EAAS1tB,OAAQhC,IACjCy4B,EAAS/I,EAAS1vB,GAClB8jC,EAAa/X,EAAI0M,EAAO1M,EAAIgY,EAAchY,EAC1C+X,EAAa9X,EAAIyM,EAAOzM,EAAI+X,EAAc/X,GAC1C0X,GAAY3U,EAAOuR,IAAIR,EAAQgE,IAEhBD,IACXA,EAAkBH,EAClBC,EAAUlL,EAqBlB,OAfAA,GAAS/I,EADOiU,EAAQ9iB,MAAQ,GAAK,EAAI8iB,EAAQ9iB,MAAQ,EAAI6O,EAAS1tB,OAAS,GAE/E8hC,EAAa/X,EAAI0M,EAAO1M,EAAIgY,EAAchY,EAC1C+X,EAAa9X,EAAIyM,EAAOzM,EAAI+X,EAAc/X,EAC1C6X,GAAmB9U,EAAOuR,IAAIR,EAAQgE,GACtCF,EAAUnL,EAGVA,EAAS/I,GADQiU,EAAQ9iB,MAAQ,GAAK6O,EAAS1tB,QAE/C8hC,EAAa/X,EAAI0M,EAAO1M,EAAIgY,EAAchY,EAC1C+X,EAAa9X,EAAIyM,EAAOzM,EAAI+X,EAAc/X,EAC1C0X,GAAY3U,EAAOuR,IAAIR,EAAQgE,GAC3BJ,EAAWG,IACXD,EAAUnL,IAGNkL,EAASC,SAKtB7N,qBAAqB,GAAGC,uBAAuB,KAAKgO,IAAI,SAASnV,EAAQ9uB,EAAOD,GAWnF,GAAImkC,KAEJlkC,GAAOD,QAAUmkC,CAEjB,IAAInV,GAAWD,EAAQ,wBACnBE,EAASF,EAAQ,sBACjBG,EAAWH,EAAQ,oBACnBI,EAASJ,EAAQ,sBACjBK,EAAOL,EAAQ,oBACftB,EAASsB,EAAQ,mBAErB,WAEIoV,EAAWC,SAAW,GACtBD,EAAWE,cAAgB,EAC3BF,EAAWG,WAAa,KAaxBH,EAAWt0B,OAAS,SAASpN,GACzB,GAAIw0B,GAAax0B,CAGbw0B,GAAWsC,QAAUtC,EAAWsN,SAChCtN,EAAWsN,QAAWtY,EAAG,EAAGC,EAAG,IAC/B+K,EAAWuC,QAAUvC,EAAWuN,SAChCvN,EAAWuN,QAAWvY,EAAG,EAAGC,EAAG,GAGnC,IAAIuY,GAAgBxN,EAAWsC,MAAQtK,EAAOpC,IAAIoK,EAAWsC,MAAMlL,SAAU4I,EAAWsN,QAAUtN,EAAWsN,OACzGG,EAAgBzN,EAAWuC,MAAQvK,EAAOpC,IAAIoK,EAAWuC,MAAMnL,SAAU4I,EAAWuN,QAAUvN,EAAWuN,OACzGtiC,EAAS+sB,EAAOmF,UAAUnF,EAAOiF,IAAIuQ,EAAeC,GAExDzN,GAAW/0B,WAAsC,KAAtB+0B,EAAW/0B,OAAyB+0B,EAAW/0B,OAASA,EAGnF+0B,EAAWviB,GAAKuiB,EAAWviB,IAAM+Y,EAAOiC,SACxCuH,EAAWnU,MAAQmU,EAAWnU,OAAS,aACvCmU,EAAW5wB,KAAO,aAClB4wB,EAAW0N,UAAY1N,EAAW0N,YAAc1N,EAAW/0B,OAAS,EAAI,EAAI,IAC5E+0B,EAAW2N,QAAU3N,EAAW2N,SAAW,EAC3C3N,EAAW4N,iBAAmB5N,EAAW4N,kBAAoB,EAC7D5N,EAAW6N,OAAS7N,EAAWsC,MAAQtC,EAAWsC,MAAMrM,MAAQ+J,EAAW6N,OAC3E7N,EAAW8N,OAAS9N,EAAWuC,MAAQvC,EAAWuC,MAAMtM,MAAQ+J,EAAW8N,OAC3E9N,EAAWtH,SAGX,IAAIrlB,IACA6mB,SAAS,EACTI,UAAW,EACXnE,YAAa,UACb/mB,KAAM,OACN2+B,SAAS,EAYb,OAT0B,KAAtB/N,EAAW/0B,QAAgB+0B,EAAW0N,UAAY,IAClDr6B,EAAOjE,KAAO,MACdiE,EAAO06B,SAAU,GACV/N,EAAW0N,UAAY,KAC9Br6B,EAAOjE,KAAO,UAGlB4wB,EAAW3sB,OAASmjB,EAAO9qB,OAAO2H,EAAQ2sB,EAAW3sB,QAE9C2sB,GASXkN,EAAWc,YAAc,SAAS7Y,GAC9B,IAAK,GAAIlsB,GAAI,EAAGA,EAAIksB,EAAOlqB,OAAQhC,GAAK,EAAG,CACvC,GAAIqgB,GAAO6L,EAAOlsB,GACd2gC,EAAUtgB,EAAK0P,iBAEf1P,GAAKkO,UAA2B,IAAdoS,EAAQ5U,GAAyB,IAAd4U,EAAQ3U,GAA6B,IAAlB2U,EAAQ3T,QAIpE3M,EAAK8N,SAASpC,GAAK4U,EAAQ5U,EAC3B1L,EAAK8N,SAASnC,GAAK2U,EAAQ3U,EAC3B3L,EAAK2M,OAAS2T,EAAQ3T,SAW9BiX,EAAWe,SAAW,SAAS3O,EAAarF,GAExC,IAAK,GAAIhxB,GAAI,EAAGA,EAAIq2B,EAAYr0B,OAAQhC,GAAK,EAAG,CAC5C,GAAI+2B,GAAaV,EAAYr2B,GACzBilC,GAAUlO,EAAWsC,OAAUtC,EAAWsC,OAAStC,EAAWsC,MAAM9K,SACpE2W,GAAUnO,EAAWuC,OAAUvC,EAAWuC,OAASvC,EAAWuC,MAAM/K,UAEpE0W,GAAUC,IACVjB,EAAWkB,MAAM9O,EAAYr2B,GAAIgxB,GAKzC,IAAKhxB,EAAI,EAAGA,EAAIq2B,EAAYr0B,OAAQhC,GAAK,EACrC+2B,EAAaV,EAAYr2B,GACzBilC,GAAUlO,EAAWsC,OAAUtC,EAAWsC,OAAStC,EAAWsC,MAAM9K,SACpE2W,GAAUnO,EAAWuC,OAAUvC,EAAWuC,OAASvC,EAAWuC,MAAM/K,SAE/D0W,GAAWC,GACZjB,EAAWkB,MAAM9O,EAAYr2B,GAAIgxB,IAY7CiT,EAAWkB,MAAQ,SAASpO,EAAY/F,GACpC,GAAIqI,GAAQtC,EAAWsC,MACnBC,EAAQvC,EAAWuC,MACnB+K,EAAStN,EAAWsN,OACpBC,EAASvN,EAAWuN,MAExB,IAAKjL,GAAUC,EAAf,CAIID,IAAUA,EAAM9K,WAChBQ,EAAOgD,OAAOsS,EAAQhL,EAAMrM,MAAQ+J,EAAW6N,OAAQP,GACvDtN,EAAW6N,OAASvL,EAAMrM,OAI1BsM,IAAUA,EAAM/K,WAChBQ,EAAOgD,OAAOuS,EAAQhL,EAAMtM,MAAQ+J,EAAW8N,OAAQP,GACvDvN,EAAW8N,OAASvL,EAAMtM,MAG9B,IAAIoY,GAAcf,EACdgB,EAAcf,CAKlB,IAHIjL,IAAO+L,EAAcrW,EAAOpC,IAAI0M,EAAMlL,SAAUkW,IAChD/K,IAAO+L,EAActW,EAAOpC,IAAI2M,EAAMnL,SAAUmW,IAE/Cc,GAAgBC,EAArB,CAGA,GAAItR,GAAQhF,EAAOiF,IAAIoR,EAAaC,GAChCC,EAAgBvW,EAAOmF,UAAUH,EAGjCuR,GAAgBrB,EAAWG,aAC3BkB,EAAgBrB,EAAWG,WAI/B,IAMIvU,GACAmS,EACAlC,EACAwB,EACAD,EAVAkE,GAAcD,EAAgBvO,EAAW/0B,QAAUsjC,EACnDb,EAAY1N,EAAW0N,UAAY,EAAI1N,EAAW0N,UAAYzT,EAAY+F,EAAW0N,UACrF7U,EAAQb,EAAO0G,KAAK1B,EAAOwR,EAAad,GACxCe,GAAanM,EAAQA,EAAMnG,YAAc,IAAMoG,EAAQA,EAAMpG,YAAc,GAC3EuS,GAAgBpM,EAAQA,EAAMlG,eAAiB,IAAMmG,EAAQA,EAAMnG,eAAiB,GACpFuS,EAAkBF,EAAYC,CAOlC,IAAI1O,EAAW2N,QAAS,CACpB,GAAIiB,GAAO5W,EAAOpf,QAClBmwB,GAAS/Q,EAAO2G,IAAI3B,EAAOuR,GAE3BjE,EAAmBtS,EAAOiF,IACtBsF,GAASvK,EAAOiF,IAAIsF,EAAMnL,SAAUmL,EAAM1H,eAAiB+T,EAC3DtM,GAAStK,EAAOiF,IAAIqF,EAAMlL,SAAUkL,EAAMzH,eAAiB+T,GAG/DrE,EAAiBvS,EAAOuR,IAAIR,EAAQuB,GAGpChI,IAAUA,EAAM9K,WAChByT,EAAQ3I,EAAMnG,YAAcsS,EAG5BnM,EAAMtJ,kBAAkBhE,GAAK6D,EAAM7D,EAAIiW,EACvC3I,EAAMtJ,kBAAkB/D,GAAK4D,EAAM5D,EAAIgW,EAGvC3I,EAAMlL,SAASpC,GAAK6D,EAAM7D,EAAIiW,EAC9B3I,EAAMlL,SAASnC,GAAK4D,EAAM5D,EAAIgW,EAG1BjL,EAAW2N,UACXrL,EAAMzH,aAAa7F,GAAKgL,EAAW2N,QAAU5E,EAAO/T,EAAIuV,EAAiBU,EACzE3I,EAAMzH,aAAa5F,GAAK+K,EAAW2N,QAAU5E,EAAO9T,EAAIsV,EAAiBU,GAI7EnS,EAAUd,EAAO6R,MAAMyD,EAAQzU,GAAS8V,EAAmBzB,EAAWE,cAAgB9K,EAAMlG,gBAAkB,EAAI4D,EAAW4N,kBAC7HtL,EAAMtJ,kBAAkB/C,OAAS6C,EACjCwJ,EAAMrM,OAAS6C,GAGfyJ,IAAUA,EAAM/K,WAChByT,EAAQ1I,EAAMpG,YAAcsS,EAG5BlM,EAAMvJ,kBAAkBhE,GAAK6D,EAAM7D,EAAIiW,EACvC1I,EAAMvJ,kBAAkB/D,GAAK4D,EAAM5D,EAAIgW,EAGvC1I,EAAMnL,SAASpC,GAAK6D,EAAM7D,EAAIiW,EAC9B1I,EAAMnL,SAASnC,GAAK4D,EAAM5D,EAAIgW,EAG1BjL,EAAW2N,UACXpL,EAAM1H,aAAa7F,GAAKgL,EAAW2N,QAAU5E,EAAO/T,EAAIuV,EAAiBU,EACzE1I,EAAM1H,aAAa5F,GAAK+K,EAAW2N,QAAU5E,EAAO9T,EAAIsV,EAAiBU,GAI7EnS,EAAUd,EAAO6R,MAAM0D,EAAQ1U,GAAS8V,EAAmBzB,EAAWE,cAAgB7K,EAAMnG,gBAAkB,EAAI4D,EAAW4N,kBAC7HrL,EAAMvJ,kBAAkB/C,OAAS6C,EACjCyJ,EAAMtM,OAAS6C,MAWvBoU,EAAW2B,aAAe,SAAS1Z,GAC/B,IAAK,GAAIlsB,GAAI,EAAGA,EAAIksB,EAAOlqB,OAAQhC,IAAK,CACpC,GAAIqgB,GAAO6L,EAAOlsB,GACd2gC,EAAUtgB,EAAK0P,iBAEnB,MAAI1P,EAAKkO,UAA2B,IAAdoS,EAAQ5U,GAAyB,IAAd4U,EAAQ3U,GAA6B,IAAlB2U,EAAQ3T,OAApE,CAIAgC,EAAS0C,IAAIrR,GAAM,EAGnB,KAAK,GAAI9X,GAAI,EAAGA,EAAI8X,EAAK1B,MAAM3c,OAAQuG,IAAK,CACxC,GAAIyqB,GAAO3S,EAAK1B,MAAMpW,EAEtBumB,GAAS0E,UAAUR,EAAKtD,SAAUiR,GAE9Bp4B,EAAI,IACJyqB,EAAK7E,SAASpC,GAAK4U,EAAQ5U,EAC3BiH,EAAK7E,SAASnC,GAAK2U,EAAQ3U,GAGT,IAAlB2U,EAAQ3T,QACR8B,EAASiD,OAAOiB,EAAKtD,SAAUiR,EAAQ3T,MAAO3M,EAAK8N,UACnDe,EAAK6C,OAAOiB,EAAKhB,KAAM2O,EAAQ3T,OAC3BzkB,EAAI,GACJwmB,EAAOkF,YAAYjB,EAAK7E,SAAUwS,EAAQ3T,MAAO3M,EAAK8N,SAAU6E,EAAK7E,WAI7Ec,EAAOgD,OAAOe,EAAKrB,OAAQqB,EAAKtD,SAAUrP,EAAK8P,UAInDwQ,EAAQ3T,OAASiX,EAAWC,SAC5BvD,EAAQ5U,GAAKkY,EAAWC,SACxBvD,EAAQ3U,GAAKiY,EAAWC,iBA4JjCvO,iBAAiB,GAAGC,mBAAmB,GAAGC,mBAAmB,GAAGC,qBAAqB,GAAGC,qBAAqB,GAAGC,uBAAuB,KAAK6P,IAAI,SAAShX,EAAQ9uB,EAAOD,GAU3K,GAAIgmC,KAEJ/lC,GAAOD,QAAUgmC,CAEjB,IAAIhX,GAAWD,EAAQ,wBACnBG,EAAWH,EAAQ,oBACnBkX,EAAQlX,EAAQ,iBAChBsH,EAAStH,EAAQ,kBACjBgK,EAAWhK,EAAQ,yBACnBoV,EAAapV,EAAQ,gBACrBT,EAAYS,EAAQ,qBACpBtB,EAASsB,EAAQ,kBACjBI,EAASJ,EAAQ,uBAErB,WAWIiX,EAAgBn2B,OAAS,SAAS6d,EAAQjrB,GACtC,GAAIyjC,IAASxY,EAASA,EAAOwY,MAAQ,QAAUzjC,EAAUA,EAAQyjC,MAAQ,KAEpEA,KACGxY,GAAUA,EAAOpjB,QAAUojB,EAAOpjB,OAAO67B,OACzCD,EAAQD,EAAMp2B,OAAO6d,EAAOpjB,OAAO67B,QAC5B1jC,GAAWA,EAAQmb,QAC1BsoB,EAAQD,EAAMp2B,OAAOpN,EAAQmb,UAE7BsoB,EAAQD,EAAMp2B,SACd4d,EAAOjZ,KAAK,qHAIpB,IAAIyiB,GAAakN,EAAWt0B,QACxBiT,MAAO,mBACPyhB,OAAQ2B,EAAM7X,SACdmW,QAAUvY,EAAG,EAAGC,EAAG,GACnBhqB,OAAQ,IACRyiC,UAAW,GACXE,iBAAkB,EAClBv6B,QACI8iB,YAAa,UACbmE,UAAW,KAIf9B,GACAppB,KAAM,kBACN6/B,MAAOA,EACPtoB,QAAS,KACT2C,KAAM,KACN0W,WAAYA,EACZnG,iBACIjO,SAAU,EACVkO,KAAM,WACNC,MAAO,IAIXoV,EAAkB3Y,EAAO9qB,OAAO8sB,EAAUhtB,EAQ9C,OANA4zB,GAAOjd,GAAGsU,EAAQ,eAAgB,WAC9B,GAAImK,GAAYvJ,EAAUuJ,UAAUnK,EAAOO,MAC3C+X,GAAgB7T,OAAOiU,EAAiBvO,GACxCmO,EAAgBK,eAAeD,KAG5BA,GAUXJ,EAAgB7T,OAAS,SAASiU,EAAiBha,GAC/C,GAAI8Z,GAAQE,EAAgBF,MACxBjP,EAAamP,EAAgBnP,WAC7B1W,EAAO6lB,EAAgB7lB,IAE3B,IAAqB,IAAjB2lB,EAAMI,QACN,GAAKrP,EAAWuC,MAsBZtK,EAAS0C,IAAIqF,EAAWuC,OAAO,GAC/BvC,EAAWsN,OAAS2B,EAAM7X,aAtB1B,KAAK,GAAInuB,GAAI,EAAGA,EAAIksB,EAAOlqB,OAAQhC,IAE/B,GADAqgB,EAAO6L,EAAOlsB,GACVivB,EAAOiQ,SAAS7e,EAAKsR,OAAQqU,EAAM7X,WAC5B0K,EAASU,WAAWlZ,EAAKuQ,gBAAiBsV,EAAgBtV,iBACjE,IAAK,GAAIroB,GAAI8X,EAAK1B,MAAM3c,OAAS,EAAI,EAAI,EAAGuG,EAAI8X,EAAK1B,MAAM3c,OAAQuG,IAAK,CACpE,GAAIyqB,GAAO3S,EAAK1B,MAAMpW,EACtB,IAAIumB,EAASoQ,SAASlM,EAAKtD,SAAUsW,EAAM7X,UAAW,CAClD4I,EAAWsN,OAAS2B,EAAM7X,SAC1B4I,EAAWuC,MAAQ4M,EAAgB7lB,KAAOA,EAC1C0W,EAAWuN,QAAWvY,EAAGia,EAAM7X,SAASpC,EAAI1L,EAAK8N,SAASpC,EAAGC,EAAGga,EAAM7X,SAASnC,EAAI3L,EAAK8N,SAASnC,GACjG+K,EAAW8N,OAASxkB,EAAK2M,MAEzBgC,EAAS0C,IAAIrR,GAAM,GACnB8V,EAAOS,QAAQsP,EAAiB,aAAeF,MAAOA,EAAO3lB,KAAMA,GAEnE,aAUpB0W,GAAWuC,MAAQ4M,EAAgB7lB,KAAO,KAC1C0W,EAAWuN,OAAS,KAEhBjkB,GACA8V,EAAOS,QAAQsP,EAAiB,WAAaF,MAAOA,EAAO3lB,KAAMA,KAU7EylB,EAAgBK,eAAiB,SAASD,GACtC,GAAIF,GAAQE,EAAgBF,MACxBK,EAAcL,EAAMM,YAEpBD,GAAYE,WACZpQ,EAAOS,QAAQsP,EAAiB,aAAeF,MAAOA,IAEtDK,EAAYG,WACZrQ,EAAOS,QAAQsP,EAAiB,aAAeF,MAAOA,IAEtDK,EAAYI,SACZtQ,EAAOS,QAAQsP,EAAiB,WAAaF,MAAOA,IAGxDD,EAAMW,kBAAkBV,SA8G7BW,oBAAoB,EAAEC,wBAAwB,EAAEjR,iBAAiB,GAAGuC,iBAAiB,GAAG2O,gBAAgB,GAAGjR,mBAAmB,GAAGE,qBAAqB,GAAGE,uBAAuB,GAAG8Q,eAAe,KAAKC,IAAI,SAASlY,EAAQ9uB,EAAOD,GAOtO,GAAIytB,KAEJxtB,GAAOD,QAAUytB,EAEjB,WAEIA,EAAOyZ,QAAU,EACjBzZ,EAAO0Z,MAAQ,EACf1Z,EAAO2Z,eAAkB,GAAI/kB,MAS7BoL,EAAO9qB,OAAS,SAASC,EAAKs0B,GAC1B,GAAImQ,GAEAC,CAEgB,kBAATpQ,IACPmQ,EAAY,EACZC,EAAYpQ,IAEZmQ,EAAY,EACZC,GAAY,EAGhB,KAAK,GAAIpnC,GAAImnC,EAAWnnC,EAAI+B,UAAUC,OAAQhC,IAAK,CAC/C,GAAIoR,GAASrP,UAAU/B,EAEvB,IAAIoR,EACA,IAAK,GAAIi2B,KAAQj2B,GACTg2B,GAAah2B,EAAOi2B,IAASj2B,EAAOi2B,GAAMt9B,cAAgBtJ,OACrDiC,EAAI2kC,IAAS3kC,EAAI2kC,GAAMt9B,cAAgBtJ,OAIxCiC,EAAI2kC,GAAQj2B,EAAOi2B,IAHnB3kC,EAAI2kC,GAAQ3kC,EAAI2kC,OAChB9Z,EAAO9qB,OAAOC,EAAI2kC,GAAOD,EAAWh2B,EAAOi2B,KAK/C3kC,EAAI2kC,GAAQj2B,EAAOi2B,GAMnC,MAAO3kC,IAUX6qB,EAAOsE,MAAQ,SAASnvB,EAAKs0B,GACzB,MAAOzJ,GAAO9qB,UAAWu0B,EAAMt0B,IASnC6qB,EAAOmP,KAAO,SAASh6B,GACnB,GAAIjC,OAAOi8B,KACP,MAAOj8B,QAAOi8B,KAAKh6B,EAGvB,IAAIg6B,KACJ,KAAK,GAAIp6B,KAAOI,GACZg6B,EAAKx6B,KAAKI,EACd,OAAOo6B,IASXnP,EAAOpZ,OAAS,SAASzR,GACrB,GAAIyR,KAEJ,IAAI1T,OAAOi8B,KAAM,CAEb,IAAK,GADDA,GAAOj8B,OAAOi8B,KAAKh6B,GACd1C,EAAI,EAAGA,EAAI08B,EAAK16B,OAAQhC,IAC7BmU,EAAOjS,KAAKQ,EAAIg6B,EAAK18B,IAEzB,OAAOmU,GAIX,IAAK,GAAI7R,KAAOI,GACZyR,EAAOjS,KAAKQ,EAAIJ,GACpB,OAAO6R,IAYXoZ,EAAO1sB,IAAM,SAAS6B,EAAK4kC,EAAMC,EAAOC,GACpCF,EAAOA,EAAK5oB,MAAM,KAAK7b,MAAM0kC,EAAOC,EAEpC,KAAK,GAAIxnC,GAAI,EAAGA,EAAIsnC,EAAKtlC,OAAQhC,GAAK,EAClC0C,EAAMA,EAAI4kC,EAAKtnC,GAGnB,OAAO0C,IAaX6qB,EAAOmE,IAAM,SAAShvB,EAAK4kC,EAAMtzB,EAAKuzB,EAAOC,GACzC,GAAI7oB,GAAQ2oB,EAAK5oB,MAAM,KAAK7b,MAAM0kC,EAAOC,EAEzC,OADAja,GAAO1sB,IAAI6B,EAAK4kC,EAAM,GAAI,GAAG3oB,EAAMA,EAAM3c,OAAS,IAAMgS,EACjDA,GAUXuZ,EAAOka,QAAU,SAAS9uB,GACtB,IAAK,GAAI3Y,GAAI2Y,EAAM3W,OAAS,EAAGhC,EAAI,EAAGA,IAAK,CACvC,GAAIuI,GAAIuO,KAAK0lB,MAAMjP,EAAOxW,UAAY/W,EAAI,IACtC0nC,EAAO/uB,EAAM3Y,EACjB2Y,GAAM3Y,GAAK2Y,EAAMpQ,GACjBoQ,EAAMpQ,GAAKm/B,EAEf,MAAO/uB,IAUX4U,EAAOtB,OAAS,SAAS0b,GACrB,MAAOA,GAAQ7wB,KAAK0lB,MAAMjP,EAAOxW,SAAW4wB,EAAQ3lC,UASxDurB,EAAOqa,UAAY,SAASllC,GACxB,MAA2B,mBAAhBmlC,aACAnlC,YAAemlC,gBAGhBnlC,GAAOA,EAAIuY,UAAYvY,EAAIlB,WASzC+rB,EAAOnP,QAAU,SAAS1b,GACtB,MAA+C,mBAAxCjC,OAAOS,UAAUoV,SAASpW,KAAKwC,IAS1C6qB,EAAOua,WAAa,SAASplC,GACzB,MAAsB,kBAARA,IASlB6qB,EAAOwa,cAAgB,SAASrlC,GAC5B,MAAsB,gBAAf,KAAOA,EAAP,YAAAoC,EAAOpC,KAAoBA,EAAIqH,cAAgBtJ,QAS1D8sB,EAAOya,SAAW,SAAStlC,GACvB,MAA8B,oBAAvB4T,SAASpW,KAAKwC,IAWzB6qB,EAAOqU,MAAQ,SAASj9B,EAAOmE,EAAK6T,GAChC,MAAIhY,GAAQmE,EACDA,EACPnE,EAAQgY,EACDA,EACJhY,GASX4oB,EAAOmU,KAAO,SAAS/8B,GACnB,MAAOA,GAAQ,GAAK,EAAI,GAS5B4oB,EAAOvR,IAAM,WACT,GAAI5N,OAAO6N,YAAa,CACpB,GAAI7N,OAAO6N,YAAYD,IACnB,MAAO5N,QAAO6N,YAAYD,KACvB,IAAI5N,OAAO6N,YAAYgsB,UAC1B,MAAO75B,QAAO6N,YAAYgsB,YAIlC,MAAQ,IAAI9lB,MAAUoL,EAAO2Z,eAWjC3Z,EAAOxW,OAAS,SAASjO,EAAK6T,GAG1B,MAFA7T,OAAsB,KAARA,EAAuBA,EAAM,EAC3C6T,MAAsB,KAARA,EAAuBA,EAAM,EACpC7T,EAAMo/B,KAAmBvrB,EAAM7T,GAG1C,IAAIo/B,GAAgB,WAGhB,MADA3a,GAAO0Z,OAAwB,KAAf1Z,EAAO0Z,MAAe,OAAS,OACxC1Z,EAAO0Z,MAAQ,OAS1B1Z,GAAO4a,cAAgB,SAASC,GAS5B,MARAA,GAAcA,EAAYhjC,QAAQ,IAAI,IAEZ,GAAtBgjC,EAAYpmC,SACZomC,EAAcA,EAAYC,OAAO,GAAKD,EAAYC,OAAO,GAC3CD,EAAYC,OAAO,GAAKD,EAAYC,OAAO,GAC3CD,EAAYC,OAAO,GAAKD,EAAYC,OAAO,IAGtDC,SAASF,EAAa,KAiBjC7a,EAAOgb,SAAW,EAQlBhb,EAAOrI,IAAM,WACL7Q,SAAWkZ,EAAOgb,SAAW,GAAKhb,EAAOgb,UAAY,GACrDl0B,QAAQ6Q,IAAIxU,MAAM2D,SAAU,cAAc1F,OAAOF,MAAMvN,UAAU2B,MAAM3C,KAAK6B,cAUpFwrB,EAAOib,KAAO,WACNn0B,SAAWkZ,EAAOgb,SAAW,GAAKhb,EAAOgb,UAAY,GACrDl0B,QAAQm0B,KAAK93B,MAAM2D,SAAU,cAAc1F,OAAOF,MAAMvN,UAAU2B,MAAM3C,KAAK6B,cAUrFwrB,EAAOjZ,KAAO,WACND,SAAWkZ,EAAOgb,SAAW,GAAKhb,EAAOgb,UAAY,GACrDl0B,QAAQC,KAAK5D,MAAM2D,SAAU,cAAc1F,OAAOF,MAAMvN,UAAU2B,MAAM3C,KAAK6B,cASrFwrB,EAAOiC,OAAS,WACZ,MAAOjC,GAAOyZ,WAUlBzZ,EAAOrW,QAAU,SAASuxB,EAAUC,GAChC,GAAID,EAASvxB,QACT,MAAOuxB,GAASvxB,QAAQwxB,EAE5B,KAAK,GAAI1oC,GAAI,EAAGA,EAAIyoC,EAASzmC,OAAQhC,IACjC,GAAIyoC,EAASzoC,KAAO0oC,EAChB,MAAO1oC,EAGf,QAAQ,GAUZutB,EAAOze,IAAM,SAASzL,EAAM6lB,GACxB,GAAI7lB,EAAKyL,IACL,MAAOzL,GAAKyL,IAAIoa,EAKpB,KAAK,GAFDyf,MAEK3oC,EAAI,EAAGA,EAAIqD,EAAKrB,OAAQhC,GAAK,EAClC2oC,EAAOzmC,KAAKgnB,EAAK7lB,EAAKrD,IAG1B,OAAO2oC,IAUXpb,EAAOqb,gBAAkB,SAASC,GAI9B,GAAI5J,MACA6J,KACApB,IAEJ,KAAK,GAAIlkC,KAAQqlC,GACRC,EAAQtlC,IAAUkkC,EAAKlkC,IACxB+pB,EAAOwb,iBAAiBvlC,EAAMslC,EAASpB,EAAMmB,EAAO5J,EAI5D,OAAOA,IAGX1R,EAAOwb,iBAAmB,SAASvlC,EAAMslC,EAASpB,EAAMmB,EAAO5J,GAC3D,GAAI+J,GAAYH,EAAMrlC,MACtBkkC,GAAKlkC,IAAQ,CAEb,KAAK,GAAIxD,GAAI,EAAGA,EAAIgpC,EAAUhnC,OAAQhC,GAAK,EAAG,CAC1C,GAAIipC,GAAWD,EAAUhpC,EAErB0nC,GAAKuB,KAKJH,EAAQG,IACT1b,EAAOwb,iBAAiBE,EAAUH,EAASpB,EAAMmB,EAAO5J,IAIhEyI,EAAKlkC,IAAQ,EACbslC,EAAQtlC,IAAQ,EAEhBy7B,EAAO/8B,KAAKsB,IAchB+pB,EAAO2b,MAAQ,WAGX,IAAK,GAFDC,MAEKnpC,EAAI,EAAGA,EAAI+B,UAAUC,OAAQhC,GAAK,EAAG,CAC1C,GAAIkpB,GAAOnnB,UAAU/B,EAEjBkpB,GAAKkgB,SAELD,EAAMjnC,KAAKwO,MAAMy4B,EAAOjgB,EAAKkgB,UAE7BD,EAAMjnC,KAAKgnB,GAInB,GAAIggB,GAAQ,WAKR,IAAK,GAHDG,GACA74B,EAAO,GAAI/B,OAAM1M,UAAUC,QAEtBhC,EAAI,EAAGC,EAAI8B,UAAUC,OAAQhC,EAAIC,EAAGD,IACzCwQ,EAAKxQ,GAAK+B,UAAU/B,EAGxB,KAAKA,EAAI,EAAGA,EAAImpC,EAAMnnC,OAAQhC,GAAK,EAAG,CAClC,GAAIi/B,GAASkK,EAAMnpC,GAAG0Q,MAAM24B,EAAY74B,OAElB,KAAXyuB,IACPoK,EAAapK,GAIrB,MAAOoK,GAKX,OAFAH,GAAME,SAAWD,EAEVD,GAYX3b,EAAO+b,gBAAkB,SAASx+B,EAAMw8B,EAAMpe,GAC1C,MAAOqE,GAAOmE,IAAI5mB,EAAMw8B,EAAM/Z,EAAO2b,MACjChgB,EACAqE,EAAO1sB,IAAIiK,EAAMw8B,MAazB/Z,EAAOgc,eAAiB,SAASz+B,EAAMw8B,EAAMpe,GACzC,MAAOqE,GAAOmE,IAAI5mB,EAAMw8B,EAAM/Z,EAAO2b,MACjC3b,EAAO1sB,IAAIiK,EAAMw8B,GACjBpe,aAMNsgB,IAAI,SAAS3a,EAAQ9uB,EAAOD,GAWlC,GAAI2tB,KAEJ1tB,GAAOD,QAAU2tB,CAEjB,IAAIf,GAAQmC,EAAQ,iBAChBG,EAAWH,EAAQ,cACnBwQ,EAAWxQ,EAAQ,yBACnBnB,EAASmB,EAAQ,oBACjBgP,EAAQhP,EAAQ,sBAEhB2L,GADU3L,EAAQ,aACXA,EAAQ,sBACfsH,EAAStH,EAAQ,YACjBT,EAAYS,EAAQ,qBACpBoV,EAAapV,EAAQ,4BACrBtB,EAASsB,EAAQ,YACjBrC,EAAOqC,EAAQ,iBAEnB,WAUIpB,EAAO9d,OAAS,SAAS+N,EAASnb,GAE9BA,EAAUgrB,EAAOqa,UAAUlqB,GAAWnb,EAAUmb,EAChDA,EAAU6P,EAAOqa,UAAUlqB,GAAWA,EAAU,KAChDnb,EAAUA,OAENmb,GAAWnb,EAAQ6H,SACnBmjB,EAAOjZ,KAAK,wDAGhB,IAAIib,IACAka,mBAAoB,EACpBC,mBAAoB,EACpBC,qBAAsB,EACtBC,gBAAgB,EAChBC,UACApa,UACAqa,QACIjN,UAAW,EACX7L,UAAW,GAEf+Y,YACItP,WAAYD,IAIhBhN,EAASD,EAAO9qB,OAAO8sB,EAAUhtB,EAGrC,IAAImb,GAAW8P,EAAOpjB,OAAQ,CAC1B,GAAI4/B,IACAtsB,QAASA,EACT+c,WAAY/M,EAGhBF,GAAOpjB,OAASmjB,EAAO9qB,OAAOunC,EAAgBxc,EAAOpjB,QAmBzD,MAfIojB,GAAOpjB,QAAUojB,EAAOpjB,OAAOqwB,aAC/BjN,EAAOpjB,OAASojB,EAAOpjB,OAAOqwB,WAAW9qB,OAAO6d,EAAOpjB,SAIvDojB,EAAOpjB,SACPojB,EAAOpjB,OAAOojB,OAASA,GAG3BA,EAAOO,MAAQxrB,EAAQwrB,OAASrB,EAAM/c,OAAO6d,EAAOO,OACpDP,EAAO2L,MAAQ0E,EAAMluB,SACrB6d,EAAOuc,WAAavc,EAAOuc,WAAWtP,WAAW9qB,OAAO6d,EAAOuc,YAC/Dvc,EAAOyc,QAAUzc,EAAOyc,UAAaC,UAAU,GAGxC1c,GAkBXC,EAAOwE,OAAS,SAASzE,EAAQuG,EAAOkB,GACpClB,EAAQA,GAAS,IAAO,GACxBkB,EAAaA,GAAc,CAE3B,IAIIj1B,GAJA+tB,EAAQP,EAAOO,MACf+b,EAAStc,EAAOsc,OAChBC,EAAavc,EAAOuc,WACpB9Q,IAIJ6Q,GAAOjN,WAAa9I,EAAQ+V,EAAO9Y,SAGnC,IAAI5qB,IACAy2B,UAAWiN,EAAOjN,UAGtB1G,GAAOS,QAAQpJ,EAAQ,eAAgBpnB,EAGvC,IAAIuxB,GAAYvJ,EAAUuJ,UAAU5J,GAChC6J,EAAiBxJ,EAAUwJ,eAAe7J,EAe9C,KAXIP,EAAOoc,gBACP5a,EAASiD,OAAO0F,EAAWmS,EAAO9Y,WAGtCvD,EAAO0c,oBAAoBxS,EAAW5J,EAAMC,SAG5CP,EAAO2c,cAAczS,EAAW5D,EAAO+V,EAAO9Y,UAAWiE,EAAYlH,EAAM4D,QAG3EsS,EAAWc,YAAYpN,GAClB33B,EAAI,EAAGA,EAAIwtB,EAAOmc,qBAAsB3pC,IACzCikC,EAAWe,SAASpN,EAAgBkS,EAAO9Y,UAE/CiT,GAAW2B,aAAajO,GAGpBoS,EAAWtP,YAEP1M,EAAMqI,YACN2T,EAAWtP,WAAWhD,MAAMsS,GAGhCA,EAAWtP,WAAWxI,OAAO8X,EAAYpS,EAAWnK,EAAQO,EAAMqI,YAClE6C,EAAkB8Q,EAAWnP,WAG7B3B,EAAkBtB,EAIlB5J,EAAMqI,YACNhI,EAAUmI,YAAYxI,GAAO,GAAO,GAAO,EAI/C,IAAIiL,GAAa+Q,EAAWrP,SAASzB,EAAiBzL,GAGlD2L,EAAQ3L,EAAO2L,MACf0D,EAAYiN,EAAOjN,SAcvB,KAbAgB,EAAM5L,OAAOkH,EAAOH,EAAY6D,GAChCgB,EAAMM,UAAUhF,EAAO0D,GAGnBrP,EAAOoc,gBACP5a,EAASqb,gBAAgBlR,EAAM91B,KAAMymC,EAAO9Y,WAG5CmI,EAAM4E,eAAe/7B,OAAS,GAC9Bm0B,EAAOS,QAAQpJ,EAAQ,kBAAoB2L,MAAOA,EAAM4E,iBAG5DsB,EAASM,iBAAiBxG,EAAM91B,MAC3BrD,EAAI,EAAGA,EAAIwtB,EAAOic,mBAAoBzpC,IACvCq/B,EAASQ,cAAc1G,EAAM91B,KAAMymC,EAAO9Y,UAM9C,KAJAqO,EAASkB,kBAAkB5I,GAG3BsM,EAAWc,YAAYpN,GAClB33B,EAAI,EAAGA,EAAIwtB,EAAOmc,qBAAsB3pC,IACzCikC,EAAWe,SAASpN,EAAgBkS,EAAO9Y,UAM/C,KAJAiT,EAAW2B,aAAajO,GAGxB0H,EAASmB,iBAAiBrH,EAAM91B,MAC3BrD,EAAI,EAAGA,EAAIwtB,EAAOkc,mBAAoB1pC,IACvCq/B,EAASwB,cAAc1H,EAAM91B,KAAMymC,EAAO9Y,UAgB9C,OAZImI,GAAM6E,gBAAgBh8B,OAAS,GAC/Bm0B,EAAOS,QAAQpJ,EAAQ,mBAAqB2L,MAAOA,EAAM6E,kBAEzD7E,EAAM8E,aAAaj8B,OAAS,GAC5Bm0B,EAAOS,QAAQpJ,EAAQ,gBAAkB2L,MAAOA,EAAM8E,eAI1DxQ,EAAO6c,mBAAmB3S,GAE1BxB,EAAOS,QAAQpJ,EAAQ,cAAepnB,GAE/BonB,GASXC,EAAOrgB,MAAQ,SAASm9B,EAASC,GAG7B,GAFAjd,EAAO9qB,OAAO8nC,EAASC,GAEnBA,EAAQzc,MAAO,CACfwc,EAAQxc,MAAQyc,EAAQzc,MAExBN,EAAOgK,MAAM8S,EAIb,KAAK,GAFDre,GAASkC,EAAUuJ,UAAU4S,EAAQxc,OAEhC/tB,EAAI,EAAGA,EAAIksB,EAAOlqB,OAAQhC,IAAK,CACpC,GAAIqgB,GAAO6L,EAAOlsB,EAClBgvB,GAAS0C,IAAIrR,GAAM,GACnBA,EAAK7L,GAAK+Y,EAAOiC,YAU7B/B,EAAOgK,MAAQ,SAASjK,GACpB,GAAIO,GAAQP,EAAOO,KAEnB8P,GAAMpG,MAAMjK,EAAO2L,MAEnB,IAAI4Q,GAAavc,EAAOuc,UACxB,IAAIA,EAAWtP,WAAY,CACvB,GAAIvO,GAASkC,EAAUuJ,UAAU5J,EACjCgc,GAAWtP,WAAWhD,MAAMsS,GAC5BA,EAAWtP,WAAWxI,OAAO8X,EAAY7d,EAAQsB,GAAQ,KAUjEC,EAAO6c,mBAAqB,SAASpe,GACjC,IAAK,GAAIlsB,GAAI,EAAGA,EAAIksB,EAAOlqB,OAAQhC,IAAK,CACpC,GAAIqgB,GAAO6L,EAAOlsB,EAGlBqgB,GAAKuP,MAAM7D,EAAI,EACf1L,EAAKuP,MAAM5D,EAAI,EACf3L,EAAKwP,OAAS,IAWtBpC,EAAO0c,oBAAsB,SAASje,EAAQ8B,GAC1C,GAAIyc,OAAwC,KAAlBzc,EAAQC,MAAwBD,EAAQC,MAAQ,IAE1E,KAAmB,IAAdD,EAAQjC,GAAyB,IAAdiC,EAAQhC,IAA6B,IAAjBye,EAI5C,IAAK,GAAIzqC,GAAI,EAAGA,EAAIksB,EAAOlqB,OAAQhC,IAAK,CACpC,GAAIqgB,GAAO6L,EAAOlsB,EAEdqgB,GAAKkO,UAAYlO,EAAKiQ,aAI1BjQ,EAAKuP,MAAM5D,GAAK3L,EAAK8R,KAAOnE,EAAQhC,EAAIye,EACxCpqB,EAAKuP,MAAM7D,GAAK1L,EAAK8R,KAAOnE,EAAQjC,EAAI0e,KAgBhDhd,EAAO2c,cAAgB,SAASle,EAAQ8I,EAAWhE,EAAWiE,EAAYyV,GACtE,IAAK,GAAI1qC,GAAI,EAAGA,EAAIksB,EAAOlqB,OAAQhC,IAAK,CACpC,GAAIqgB,GAAO6L,EAAOlsB,EAEdqgB,GAAKkO,UAAYlO,EAAKiQ,YAG1B9D,EAAKyF,OAAO5R,EAAM2U,EAAWhE,EAAWiE,UA2KjD0V,eAAe,EAAEhE,oBAAoB,EAAEiE,gBAAgB,EAAEC,oBAAoB,EAAEC,qBAAqB,EAAEC,wBAAwB,GAAG1S,2BAA2B,GAAGpC,mBAAmB,GAAG+U,WAAW,GAAGC,WAAW,GAAGC,YAAY,GAAGC,aAAa,KAAKC,IAAI,SAASvc,EAAQ9uB,EAAOD,GASjR,GAAIq2B,KAEJp2B,GAAOD,QAAUq2B,CAEjB,IAAI5I,GAASsB,EAAQ,aAErB,WASIsH,EAAOjd,GAAK,SAASlY,EAAQqqC,EAAYx9B,GAIrC,IAAK,GAFDvN,GADAgrC,EAAQD,EAAW3sB,MAAM,KAGpB1e,EAAI,EAAGA,EAAIsrC,EAAMtpC,OAAQhC,IAC9BM,EAAOgrC,EAAMtrC,GACbgB,EAAO6oC,OAAS7oC,EAAO6oC,WACvB7oC,EAAO6oC,OAAOvpC,GAAQU,EAAO6oC,OAAOvpC,OACpCU,EAAO6oC,OAAOvpC,GAAM4B,KAAK2L,EAG7B,OAAOA,IAUXsoB,EAAO9c,IAAM,SAASrY,EAAQqqC,EAAYx9B,GACtC,IAAKw9B,EAED,YADArqC,EAAO6oC,UAKe,mBAAfwB,KACPx9B,EAAWw9B,EACXA,EAAa9d,EAAOmP,KAAK17B,EAAO6oC,QAAQ76B,KAAK,KAKjD,KAAK,GAFDs8B,GAAQD,EAAW3sB,MAAM,KAEpB1e,EAAI,EAAGA,EAAIsrC,EAAMtpC,OAAQhC,IAAK,CACnC,GAAIurC,GAAYvqC,EAAO6oC,OAAOyB,EAAMtrC,IAChCwrC,IAEJ,IAAI39B,GAAY09B,EACZ,IAAK,GAAIhjC,GAAI,EAAGA,EAAIgjC,EAAUvpC,OAAQuG,IAC9BgjC,EAAUhjC,KAAOsF,GACjB29B,EAAatpC,KAAKqpC,EAAUhjC,GAIxCvH,GAAO6oC,OAAOyB,EAAMtrC,IAAMwrC,IAWlCrV,EAAOS,QAAU,SAAS51B,EAAQqqC,EAAYjlC,GAC1C,GAAIklC,GACAhrC,EACAirC,EACAE,CAEJ,IAAIzqC,EAAO6oC,OAAQ,CACVzjC,IACDA,MAEJklC,EAAQD,EAAW3sB,MAAM,IAEzB,KAAK,GAAI1e,GAAI,EAAGA,EAAIsrC,EAAMtpC,OAAQhC,IAI9B,GAHAM,EAAOgrC,EAAMtrC,GACburC,EAAYvqC,EAAO6oC,OAAOvpC,GAEX,CACXmrC,EAAale,EAAOsE,MAAMzrB,GAAO,GACjCqlC,EAAWnrC,KAAOA,EAClBmrC,EAAWr6B,OAASpQ,CAEpB,KAAK,GAAIuH,GAAI,EAAGA,EAAIgjC,EAAUvpC,OAAQuG,IAClCgjC,EAAUhjC,GAAGmI,MAAM1P,GAASyqC,YASjDT,WAAW,KAAKU,IAAI,SAAS7c,EAAQ9uB,EAAOD,GAO/C,GAAIm4B,KAEJl4B,GAAOD,QAAUm4B,CAEjB,IAAI0T,GAAS9c,EAAQ,YACjBtB,EAASsB,EAAQ,aAErB,WAQIoJ,EAAO33B,KAAO,YAQd23B,EAAOjf,QAAU,SAQjBif,EAAO2T,QAQP3T,EAAO4T,QAUP5T,EAAO6T,IAAM,WACTH,EAAOG,IAAI7T,EAAQxpB,MAAMvN,UAAU2B,MAAM3C,KAAK6B,aAWlDk2B,EAAO8T,OAAS,SAASzE,EAAMpe,GAE3B,MADAoe,GAAOA,EAAKliC,QAAQ,WAAY,IACzBmoB,EAAO+b,gBAAgBrR,EAAQqP,EAAMpe,IAWhD+O,EAAO+T,MAAQ,SAAS1E,EAAMpe,GAE1B,MADAoe,GAAOA,EAAKliC,QAAQ,WAAY,IACzBmoB,EAAOgc,eAAetR,EAAQqP,EAAMpe,SAKhD8hB,WAAW,GAAGiB,WAAW,KAAKC,IAAI,SAASrd,EAAQ9uB,EAAOD,MAE1D6mC,oBAAoB,EAAEqE,WAAW,KAAKmB,IAAI,SAAStd,EAAQ9uB,EAAOD,GAOrE,GAAIimC,KAEJhmC,GAAOD,QAAUimC,CAEjB,IAAIxY,GAASsB,EAAQ,mBAErB,WAQIkX,EAAMp2B,OAAS,SAAS+N,GACpB,GAAIsoB,KAqFJ,OAnFKtoB,IACD6P,EAAOrI,IAAI,mEAAoE,QAGnF8gB,EAAMtoB,QAAUA,GAAWvZ,SAASkc,KACpC2lB,EAAMoG,UAAargB,EAAG,EAAGC,EAAG,GAC5Bga,EAAM7X,UAAapC,EAAG,EAAGC,EAAG,GAC5Bga,EAAMqG,mBAAsBtgB,EAAG,EAAGC,EAAG,GACrCga,EAAMsG,iBAAoBvgB,EAAG,EAAGC,EAAG,GACnCga,EAAMzQ,QAAWxJ,EAAG,EAAGC,EAAG,GAC1Bga,EAAM/X,OAAUlC,EAAG,EAAGC,EAAG,GACzBga,EAAMuG,WAAa,EACnBvG,EAAMI,QAAU,EAChBJ,EAAMwG,WAAaxG,EAAMtoB,QAAQ2D,aAAa,qBAAuB,EAErE2kB,EAAMM,cACFC,UAAW,KACXC,UAAW,KACXC,QAAS,KACTgG,WAAY,MAGhBzG,EAAMO,UAAY,SAASngC,GACvB,GAAI+nB,GAAW4X,EAAM2G,0BAA0BtmC,EAAO4/B,EAAMtoB,QAASsoB,EAAMwG,WAC7DpmC,GAAMumC,iBAGhB3G,EAAMI,OAAS,EACfhgC,EAAMwmC,kBAGV5G,EAAMoG,SAASrgB,EAAIoC,EAASpC,EAC5Bia,EAAMoG,SAASpgB,EAAImC,EAASnC,EAC5Bga,EAAM7X,SAASpC,EAAIia,EAAMoG,SAASrgB,EAAIia,EAAM/X,MAAMlC,EAAIia,EAAMzQ,OAAOxJ,EACnEia,EAAM7X,SAASnC,EAAIga,EAAMoG,SAASpgB,EAAIga,EAAM/X,MAAMjC,EAAIga,EAAMzQ,OAAOvJ,EACnEga,EAAMM,aAAaC,UAAYngC,GAGnC4/B,EAAMQ,UAAY,SAASpgC,GACvB,GAAI+nB,GAAW4X,EAAM2G,0BAA0BtmC,EAAO4/B,EAAMtoB,QAASsoB,EAAMwG,WAC7DpmC,GAAMumC,gBAGhB3G,EAAMI,OAAS,EACfhgC,EAAMwmC,kBAEN5G,EAAMI,OAAShgC,EAAMggC,OAGzBJ,EAAMoG,SAASrgB,EAAIoC,EAASpC,EAC5Bia,EAAMoG,SAASpgB,EAAImC,EAASnC,EAC5Bga,EAAM7X,SAASpC,EAAIia,EAAMoG,SAASrgB,EAAIia,EAAM/X,MAAMlC,EAAIia,EAAMzQ,OAAOxJ,EACnEia,EAAM7X,SAASnC,EAAIga,EAAMoG,SAASpgB,EAAIga,EAAM/X,MAAMjC,EAAIga,EAAMzQ,OAAOvJ,EACnEga,EAAMqG,kBAAkBtgB,EAAIia,EAAM7X,SAASpC,EAC3Cia,EAAMqG,kBAAkBrgB,EAAIga,EAAM7X,SAASnC,EAC3Cga,EAAMM,aAAaE,UAAYpgC,GAGnC4/B,EAAMS,QAAU,SAASrgC,GACrB,GAAI+nB,GAAW4X,EAAM2G,0BAA0BtmC,EAAO4/B,EAAMtoB,QAASsoB,EAAMwG,WAC7DpmC,GAAMumC,gBAGhBvmC,EAAMwmC,iBAGV5G,EAAMI,QAAU,EAChBJ,EAAMoG,SAASrgB,EAAIoC,EAASpC,EAC5Bia,EAAMoG,SAASpgB,EAAImC,EAASnC,EAC5Bga,EAAM7X,SAASpC,EAAIia,EAAMoG,SAASrgB,EAAIia,EAAM/X,MAAMlC,EAAIia,EAAMzQ,OAAOxJ,EACnEia,EAAM7X,SAASnC,EAAIga,EAAMoG,SAASpgB,EAAIga,EAAM/X,MAAMjC,EAAIga,EAAMzQ,OAAOvJ,EACnEga,EAAMsG,gBAAgBvgB,EAAIia,EAAM7X,SAASpC,EACzCia,EAAMsG,gBAAgBtgB,EAAIga,EAAM7X,SAASnC,EACzCga,EAAMM,aAAaG,QAAUrgC,GAGjC4/B,EAAMyG,WAAa,SAASrmC,GACxB4/B,EAAMuG,WAAaz1B,KAAK6F,KAAK,EAAG7F,KAAKhO,IAAI,EAAG1C,EAAMmmC,aAAenmC,EAAMymC,SACvEzmC,EAAMwmC,kBAGV7G,EAAM+G,WAAW9G,EAAOA,EAAMtoB,SAEvBsoB,GASXD,EAAM+G,WAAa,SAAS9G,EAAOtoB,GAC/BsoB,EAAMtoB,QAAUA,EAEhBA,EAAQpY,iBAAiB,YAAa0gC,EAAMO,WAC5C7oB,EAAQpY,iBAAiB,YAAa0gC,EAAMQ,WAC5C9oB,EAAQpY,iBAAiB,UAAW0gC,EAAMS,SAE1C/oB,EAAQpY,iBAAiB,aAAc0gC,EAAMyG,YAC7C/uB,EAAQpY,iBAAiB,iBAAkB0gC,EAAMyG,YAEjD/uB,EAAQpY,iBAAiB,YAAa0gC,EAAMO,WAC5C7oB,EAAQpY,iBAAiB,aAAc0gC,EAAMQ,WAC7C9oB,EAAQpY,iBAAiB,WAAY0gC,EAAMS,UAQ/CV,EAAMW,kBAAoB,SAASV,GAC/BA,EAAMM,aAAaC,UAAY,KAC/BP,EAAMM,aAAaE,UAAY,KAC/BR,EAAMM,aAAaG,QAAU,KAC7BT,EAAMM,aAAamG,WAAa,KAChCzG,EAAMuG,WAAa,GASvBxG,EAAMgH,UAAY,SAAS/G,EAAOzQ,GAC9ByQ,EAAMzQ,OAAOxJ,EAAIwJ,EAAOxJ,EACxBia,EAAMzQ,OAAOvJ,EAAIuJ,EAAOvJ,EACxBga,EAAM7X,SAASpC,EAAIia,EAAMoG,SAASrgB,EAAIia,EAAM/X,MAAMlC,EAAIia,EAAMzQ,OAAOxJ,EACnEia,EAAM7X,SAASnC,EAAIga,EAAMoG,SAASpgB,EAAIga,EAAM/X,MAAMjC,EAAIga,EAAMzQ,OAAOvJ,GASvE+Z,EAAMiH,SAAW,SAAShH,EAAO/X,GAC7B+X,EAAM/X,MAAMlC,EAAIkC,EAAMlC,EACtBia,EAAM/X,MAAMjC,EAAIiC,EAAMjC,EACtBga,EAAM7X,SAASpC,EAAIia,EAAMoG,SAASrgB,EAAIia,EAAM/X,MAAMlC,EAAIia,EAAMzQ,OAAOxJ,EACnEia,EAAM7X,SAASnC,EAAIga,EAAMoG,SAASpgB,EAAIga,EAAM/X,MAAMjC,EAAIga,EAAMzQ,OAAOvJ,GAYvE+Z,EAAM2G,0BAA4B,SAAStmC,EAAOsX,EAAS8uB,GACvD,GAKIzgB,GAAGC,EALHihB,EAAgBvvB,EAAQX,wBACxBmwB,EAAY/oC,SAASsT,iBAAmBtT,SAASkc,KAAK9b,YAAcJ,SAASkc,KAC7E8sB,MAAkC/qC,KAAvBgM,OAAOg/B,YAA6Bh/B,OAAOg/B,YAAcF,EAASG,WAC7EC,MAAkClrC,KAAvBgM,OAAOm/B,YAA6Bn/B,OAAOm/B,YAAcL,EAASM,UAC7EC,EAAUrnC,EAAMumC,cAWpB,OARIc,IACA1hB,EAAI0hB,EAAQ,GAAGC,MAAQT,EAAcpwB,KAAOswB,EAC5CnhB,EAAIyhB,EAAQ,GAAGE,MAAQV,EAAcvwB,IAAM4wB,IAE3CvhB,EAAI3lB,EAAMsnC,MAAQT,EAAcpwB,KAAOswB,EACvCnhB,EAAI5lB,EAAMunC,MAAQV,EAAcvwB,IAAM4wB,IAItCvhB,EAAGA,GAAKrO,EAAQ6C,aAAe7C,EAAQ/C,OAAS+C,EAAQ6C,aAAeisB,GACvExgB,EAAGA,GAAKtO,EAAQ8C,cAAgB9C,EAAQ9C,QAAU8C,EAAQ8C,cAAgBgsB,UAMnF7W,iBAAiB,KAAKiY,IAAI,SAAS/e,EAAQ9uB,EAAOD,GAOrD,GAAI6rC,KAEJ5rC,GAAOD,QAAU6rC,CAEjB,IAAIpe,GAASsB,EAAQ,aAErB,WAEI8c,EAAOkC,aAQPlC,EAAOhnB,SAAW,SAAS8K,GAKvB,GAJKkc,EAAOmC,SAASre,IACjBlC,EAAOjZ,KAAK,mBAAoBq3B,EAAOr1B,SAASmZ,GAAS,2CAGzDA,EAAOnvB,OAAQqrC,GAAOkC,UAAW,CACjC,GAAIE,GAAapC,EAAOkC,UAAUpe,EAAOnvB,MACrC0tC,EAAgBrC,EAAOsC,aAAaxe,EAAOzW,SAASk1B,OACpDC,EAAoBxC,EAAOsC,aAAaF,EAAW/0B,SAASk1B,MAE5DF,GAAgBG,GAChB5gB,EAAOjZ,KAAK,mBAAoBq3B,EAAOr1B,SAASy3B,GAAa,kBAAmBpC,EAAOr1B,SAASmZ,IAChGkc,EAAOkC,UAAUpe,EAAOnvB,MAAQmvB,GACzBue,EAAgBG,EACvB5gB,EAAOjZ,KAAK,mBAAoBq3B,EAAOr1B,SAASy3B,GAAa,2BAA4BpC,EAAOr1B,SAASmZ,IAClGA,IAAWse,GAClBxgB,EAAOjZ,KAAK,mBAAoBq3B,EAAOr1B,SAASmZ,GAAS,wDAG7Dkc,GAAOkC,UAAUpe,EAAOnvB,MAAQmvB,CAGpC,OAAOA,IAUXkc,EAAOn+B,QAAU,SAAS4gC,GACtB,MAAOzC,GAAOkC,UAAUlC,EAAO0C,gBAAgBD,GAAY9tC,OAS/DqrC,EAAOr1B,SAAW,SAASmZ,GACvB,MAAyB,gBAAXA,GAAsBA,GAAUA,EAAOnvB,MAAQ,aAAe,KAAOmvB,EAAOzW,SAAWyW,EAAO6e,OAAS,UAazH3C,EAAOmC,SAAW,SAASprC,GACvB,MAAOA,IAAOA,EAAIpC,MAAQoC,EAAIsW,SAAWtW,EAAI6rC,SAUjD5C,EAAO6C,OAAS,SAASzuC,EAAQO,GAC7B,MAAOP,GAAO8rC,KAAK30B,QAAQ5W,IAAS,GAYxCqrC,EAAO8C,MAAQ,SAAShf,EAAQ1vB,GAC5B,GAAI2uC,GAASjf,EAAOkf,KAAOhD,EAAO0C,gBAAgB5e,EAAOkf,IACzD,QAAQlf,EAAOkf,KAAQ5uC,EAAOO,OAASouC,EAAOpuC,MAAQqrC,EAAOiD,iBAAiB7uC,EAAOiZ,QAAS01B,EAAOJ,QAmBzG3C,EAAOG,IAAM,SAAS/rC,EAAQ8uC,GAG1B,GAFA9uC,EAAO6rC,MAAQ7rC,EAAO6rC,UAAYj9B,OAAOkgC,OAEd,IAAvB9uC,EAAO6rC,KAAK5pC,OAEZ,WADAurB,GAAOjZ,KAAK,cAAeq3B,EAAOr1B,SAASvW,GAAS,gDAQxD,KAAK,GAJD+uC,GAAenD,EAAOmD,aAAa/uC,GACnCgvC,EAAqBxhB,EAAOqb,gBAAgBkG,GAC5CE,KAEKhvC,EAAI,EAAGA,EAAI+uC,EAAmB/sC,OAAQhC,GAAK,EAChD,GAAI+uC,EAAmB/uC,KAAOD,EAAOO,KAArC,CAIA,GAAImvB,GAASkc,EAAOn+B,QAAQuhC,EAAmB/uC,GAE1CyvB,GAKDkc,EAAO6C,OAAOzuC,EAAQ0vB,EAAOnvB,QAI5BqrC,EAAO8C,MAAMhf,EAAQ1vB,KACtBwtB,EAAOjZ,KAAK,cAAeq3B,EAAOr1B,SAASmZ,GAAS,SAAUA,EAAOkf,IAAK,mBAAoBhD,EAAOr1B,SAASvW,GAAU,KACxH0vB,EAAOwf,SAAU,GAGjBxf,EAAO8e,QACP9e,EAAO8e,QAAQxuC,IAEfwtB,EAAOjZ,KAAK,cAAeq3B,EAAOr1B,SAASmZ,GAAS,yCACpDA,EAAOwf,SAAU,GAGjBxf,EAAOwf,SACPD,EAAO9sC,KAAK,MAAQypC,EAAOr1B,SAASmZ,UAC7BA,GAAOwf,SAEdD,EAAO9sC,KAAK,KAAOypC,EAAOr1B,SAASmZ,IAGvC1vB,EAAO8rC,KAAK3pC,KAAKutB,EAAOnvB,OA3BpB0uC,EAAO9sC,KAAK,KAAO6sC,EAAmB/uC,IA8B1CgvC,EAAOhtC,OAAS,GAChBurB,EAAOib,KAAKwG,EAAOhgC,KAAK,QAUhC28B,EAAOmD,aAAe,SAAS/uC,EAAQmvC,GACnC,GAAIC,GAAaxD,EAAO0C,gBAAgBtuC,GACpCO,EAAO6uC,EAAW7uC,IAItB,IAFA4uC,EAAUA,QAEN5uC,IAAQ4uC,IAAZ,CAIAnvC,EAAS4rC,EAAOn+B,QAAQzN,IAAWA,EAEnCmvC,EAAQ5uC,GAAQitB,EAAOze,IAAI/O,EAAO6rC,SAAY,SAASwC,GAC/CzC,EAAOmC,SAASM,IAChBzC,EAAOhnB,SAASypB,EAGpB,IAAIM,GAAS/C,EAAO0C,gBAAgBD,GAChCgB,EAAWzD,EAAOn+B,QAAQ4gC,EAmB9B,OAjBIgB,KAAazD,EAAOiD,iBAAiBQ,EAASp2B,QAAS01B,EAAOJ,QAC9D/gB,EAAOjZ,KACH,uBAAwBq3B,EAAOr1B,SAAS84B,GAAW,mBACnDzD,EAAOr1B,SAASo4B,GAAS,UAAW/C,EAAOr1B,SAAS64B,GAAc,KAGtEC,EAASH,SAAU,EACnBlvC,EAAOkvC,SAAU,GACTG,IACR7hB,EAAOjZ,KACH,uBAAwBq3B,EAAOr1B,SAAS83B,GAAa,UACrDzC,EAAOr1B,SAAS64B,GAAa,0BAGjCpvC,EAAOkvC,SAAU,GAGdP,EAAOpuC,MAGlB,KAAK,GAAIN,GAAI,EAAGA,EAAIkvC,EAAQ5uC,GAAM0B,OAAQhC,GAAK,EAC3C2rC,EAAOmD,aAAaI,EAAQ5uC,GAAMN,GAAIkvC,EAG1C,OAAOA,KAYXvD,EAAO0C,gBAAkB,SAASD,GAC9B,GAAI7gB,EAAOya,SAASoG,GAAa,CAO7B,MANc,wDAEDppC,KAAKopC,IACd7gB,EAAOjZ,KAAK,0BAA2B85B,EAAY,sCAInD9tC,KAAM8tC,EAAW1vB,MAAM,KAAK,GAC5B4vB,MAAOF,EAAW1vB,MAAM,KAAK,IAAM,KAI3C,OACIpe,KAAM8tC,EAAW9tC,KACjBguC,MAAOF,EAAWE,OAASF,EAAWp1B,UAkB9C2yB,EAAOsC,aAAe,SAASK,GACb,4CAEDtpC,KAAKspC,IACd/gB,EAAOjZ,KAAK,uBAAwBg6B,EAAO,mCAG/C,IAAIe,GAAcf,EAAM5vB,MAAM,IAC9B4vB,GAAQe,EAAY,EAEpB,IAAIC,GAAUhxB,MAAMglB,OAAOgL,EAAM,KAC7Bt1B,EAAUs2B,EAAUhB,EAAMrqB,OAAO,GAAKqqB,EACtC3vB,EAAQ4O,EAAOze,IAAIkK,EAAQ0F,MAAM,KAAM,SAASsU,GAC5C,MAAOsQ,QAAOtQ,IAGtB,QACIsc,QAASA,EACTt2B,QAASA,EACTs1B,MAAOA,EACPiB,SAAUD,EAAUhB,EAAM,GAAK,GAC/B3vB,MAAOA,EACP6wB,WAAYH,EAAY,GACxBnB,OAAmB,IAAXvvB,EAAM,GAAsB,IAAXA,EAAM,GAAWA,EAAM,KAaxDgtB,EAAOiD,iBAAmB,SAAS51B,EAASs1B,GACxCA,EAAQA,GAAS,GAEjB,IAAImB,GAAc9D,EAAOsC,aAAaK,GAClCoB,EAAaD,EAAY9wB,MACzBgxB,EAAgBhE,EAAOsC,aAAaj1B,GACpC42B,EAAeD,EAAchxB,KAEjC,IAAI8wB,EAAYH,QAAS,CACrB,GAA6B,MAAzBG,EAAYF,UAAgC,MAAZv2B,EAChC,OAAO,CAGX,IAA6B,MAAzBy2B,EAAYF,SACZ,MAAOK,GAAa,KAAOF,EAAW,IAAME,EAAa,KAAOF,EAAW,IAAME,EAAa,IAAMF,EAAW,EAGnH,IAA6B,MAAzBD,EAAYF,SACZ,MAAIG,GAAW,GAAK,EACTE,EAAa,KAAOF,EAAW,IAAMC,EAAczB,QAAUuB,EAAYvB,OAGhFwB,EAAW,GAAK,EACTE,EAAa,KAAOF,EAAW,IAAME,EAAa,IAAMF,EAAW,GAGvEE,EAAa,KAAOF,EAAW,GAI9C,MAAO12B,KAAYs1B,GAAqB,MAAZt1B,QAKjCgyB,WAAW,KAAK6E,IAAI,SAAShhB,EAAQ9uB,EAAOD,GAa/C,GAAIguB,KAEJ/tB,GAAOD,QAAUguB,CAEjB,IAAIqI,GAAStH,EAAQ,YACjBpB,EAASoB,EAAQ,YACjBtB,EAASsB,EAAQ,aAErB,WAEI,GAAIihB,GACAC,CAUJ,IARsB,mBAAX3hC,UACP0hC,EAAyB1hC,OAAO4hC,uBAAyB5hC,OAAO6hC,6BAC/B7hC,OAAO8hC,0BAA4B9hC,OAAO+hC,wBAE3EJ,EAAwB3hC,OAAOgiC,sBAAwBhiC,OAAOiiC,yBAC7BjiC,OAAOkiC,4BAA8BliC,OAAOmiC,yBAG5ET,EAAwB,CACzB,GAAIU,EAEJV,GAAyB,SAASjiC,GAC9B2iC,EAAgB7iC,WAAW,WACvBE,EAAS0f,EAAOvR,QACjB,IAAO,KAGd+zB,EAAwB,WACpBn7B,aAAa47B,IASrB1iB,EAAOne,OAAS,SAASpN,GACrB,GAAIgtB,IACAxH,IAAK,GACLkN,WAAY,EACZwb,gBAAiB,GACjBC,iBAAkB,EAClBC,aAAc,EACdC,gBACAC,SAAU,KACVC,cAAe,EACfC,eAAgB,KAChBC,SAAS,EACTC,SAAS,GAGTpjB,EAASN,EAAO9qB,OAAO8sB,EAAUhtB,EAOrC,OALAsrB,GAAOkG,MAAQlG,EAAOkG,OAAS,IAAOlG,EAAO9F,IAC7C8F,EAAOqjB,SAAWrjB,EAAOqjB,UAAY,IAAOrjB,EAAO9F,IACnD8F,EAAOsjB,SAAWtjB,EAAOsjB,UAAY,KAAqB,GAAbtjB,EAAO9F,KACpD8F,EAAO9F,IAAM,IAAO8F,EAAOkG,MAEpBlG,GAQXC,EAAO7X,IAAM,SAAS4X,EAAQL,GAe1B,WAbyC,KAA9BK,EAAO4b,qBACdjc,EAASK,EACTA,EAASC,EAAOne,UAGpB,QAAUvF,GAAO+P,GACb0T,EAAOkjB,eAAiBjB,EAAuB1lC,GAE3C+P,GAAQ0T,EAAOojB,SACfnjB,EAAOsjB,KAAKvjB,EAAQL,EAAQrT,MAI7B0T,GAaXC,EAAOsjB,KAAO,SAASvjB,EAAQL,EAAQrT,GACnC,GAEI4Z,GAFA+V,EAAStc,EAAOsc,OAChB7U,EAAa,EAIb7uB,GACAy2B,UAAWiN,EAAOjN,UAGtB1G,GAAOS,QAAQ/I,EAAQ,aAAcznB,GACrC+vB,EAAOS,QAAQpJ,EAAQ,aAAcpnB,GAEjCynB,EAAOmjB,QAEPjd,EAAQlG,EAAOkG,OAGfA,EAAS5Z,EAAO0T,EAAOgjB,UAAahjB,EAAOkG,MAC3ClG,EAAOgjB,SAAW12B,EAGlB0T,EAAO+iB,aAAa1uC,KAAK6xB,GACzBlG,EAAO+iB,aAAe/iB,EAAO+iB,aAAa/tC,OAAOgrB,EAAO4iB,iBACxD1c,EAAQjd,KAAKhO,IAAI4H,MAAM,KAAMmd,EAAO+iB,cAGpC7c,EAAQA,EAAQlG,EAAOqjB,SAAWrjB,EAAOqjB,SAAWnd,EACpDA,EAAQA,EAAQlG,EAAOsjB,SAAWtjB,EAAOsjB,SAAWpd,EAGpDkB,EAAalB,EAAQlG,EAAOkG,MAG5BlG,EAAOkG,MAAQA,GAIU,IAAzBlG,EAAOijB,gBACP7b,GAAc6U,EAAO9Y,UAAYnD,EAAOijB,eAEnB,IAArBhH,EAAO9Y,YACPiE,EAAa,GAEjBpH,EAAOijB,cAAgBhH,EAAO9Y,UAC9BnD,EAAOoH,WAAaA,EAGpBpH,EAAO8iB,cAAgB,EACnBx2B,EAAO0T,EAAO6iB,kBAAoB,MAClC7iB,EAAO9F,IAAM8F,EAAO8iB,eAAiBx2B,EAAO0T,EAAO6iB,kBAAoB,KACvE7iB,EAAO6iB,iBAAmBv2B,EAC1B0T,EAAO8iB,aAAe,GAG1Bxa,EAAOS,QAAQ/I,EAAQ,OAAQznB,GAC/B+vB,EAAOS,QAAQpJ,EAAQ,OAAQpnB,GAG3BonB,EAAOO,MAAMqI,YACV5I,EAAOpjB,QACPojB,EAAOpjB,OAAOqwB,YACdjN,EAAOpjB,OAAOqwB,WAAWhD,OAC5BjK,EAAOpjB,OAAOqwB,WAAWhD,MAAMjK,EAAOpjB,QAI1C+rB,EAAOS,QAAQ/I,EAAQ,eAAgBznB,GACvCqnB,EAAOwE,OAAOzE,EAAQuG,EAAOkB,GAC7BkB,EAAOS,QAAQ/I,EAAQ,cAAeznB,GAIlConB,EAAOpjB,QAAUojB,EAAOpjB,OAAOqwB,aAC/BtE,EAAOS,QAAQ/I,EAAQ,eAAgBznB,GACvC+vB,EAAOS,QAAQpJ,EAAQ,eAAgBpnB,GAEvConB,EAAOpjB,OAAOqwB,WAAW1M,MAAMP,EAAOpjB,QAEtC+rB,EAAOS,QAAQ/I,EAAQ,cAAeznB,GACtC+vB,EAAOS,QAAQpJ,EAAQ,cAAepnB,IAG1C+vB,EAAOS,QAAQ/I,EAAQ,YAAaznB,GACpC+vB,EAAOS,QAAQpJ,EAAQ,YAAapnB,IASxC0nB,EAAOujB,KAAO,SAASxjB,GACnBkiB,EAAsBliB,EAAOkjB,iBASjCjjB,EAAOwjB,MAAQ,SAASzjB,EAAQL,GAC5BM,EAAO7X,IAAI4X,EAAQL,SAqHxBwd,WAAW,GAAGuG,WAAW,GAAGtG,WAAW,KAAKuG,IAAI,SAAS3iB,EAAQ9uB,EAAOD,GAO3E,GAAIkvB,KAEJjvB,GAAOD,QAAUkvB,CAEjB,IAAImH,GAAStH,EAAQ,aAErB,WAEIG,EAASyiB,qBAAuB,IAChCziB,EAAS0iB,sBAAwB,IACjC1iB,EAAS2iB,SAAW,GAQpB3iB,EAASiD,OAAS,SAAS/F,EAAQ8E,GAI/B,IAAK,GAHD4gB,GAAa5gB,EAAYA,EAAYA,EAGhChxB,EAAI,EAAGA,EAAIksB,EAAOlqB,OAAQhC,IAAK,CACpC,GAAIqgB,GAAO6L,EAAOlsB,GACduwB,EAASlQ,EAAK4P,MAAQ5P,EAAK4P,MAAQ5P,EAAK6P,aAAe7P,EAAK6P,YAGhE,IAAqB,IAAjB7P,EAAKuP,MAAM7D,GAA4B,IAAjB1L,EAAKuP,MAAM5D,EAArC,CAKA,GAAI6lB,GAAY/6B,KAAKhO,IAAIuX,EAAKkQ,OAAQA,GAClCuhB,EAAYh7B,KAAK6F,IAAI0D,EAAKkQ,OAAQA,EAGtClQ,GAAKkQ,OAASvB,EAAS2iB,SAAWE,GAAa,EAAI7iB,EAAS2iB,UAAYG,EAEpEzxB,EAAKmQ,eAAiB,GAAKnQ,EAAKkQ,OAASvB,EAAS0iB,sBAAwBE,GAC1EvxB,EAAK0xB,cAAgB,EAEjB1xB,EAAK0xB,cAAgB1xB,EAAKmQ,gBAC1BxB,EAAS0C,IAAIrR,GAAM,IAChBA,EAAK0xB,aAAe,IAC3B1xB,EAAK0xB,cAAgB,OAhBrB/iB,GAAS0C,IAAIrR,GAAM,KA2B/B2O,EAASqb,gBAAkB,SAASlR,EAAOnI,GAIvC,IAAK,GAHD4gB,GAAa5gB,EAAYA,EAAYA,EAGhChxB,EAAI,EAAGA,EAAIm5B,EAAMn3B,OAAQhC,IAAK,CACnC,GAAI85B,GAAOX,EAAMn5B,EAGjB,IAAK85B,EAAKC,SAAV,CAGA,GAAIC,GAAYF,EAAKE,UACjBX,EAAQW,EAAUX,MAAMxyB,OACxByyB,EAAQU,EAAUV,MAAMzyB,MAG5B,MAAKwyB,EAAM/I,YAAcgJ,EAAMhJ,YAAe+I,EAAM9K,UAAY+K,EAAM/K,YAGlE8K,EAAM/I,YAAcgJ,EAAMhJ,YAAY,CACtC,GAAI0hB,GAAgB3Y,EAAM/I,aAAe+I,EAAM9K,SAAY8K,EAAQC,EAC/D2Y,EAAaD,IAAiB3Y,EAAQC,EAAQD,GAE7C2Y,EAAazjB,UAAY0jB,EAAW1hB,OAASvB,EAASyiB,qBAAuBG,GAC9E5iB,EAAS0C,IAAIsgB,GAAc,OAY3ChjB,EAAS0C,IAAM,SAASrR,EAAMiQ,GAC1B,GAAI4hB,GAAc7xB,EAAKiQ,UAEnBA,IACAjQ,EAAKiQ,YAAa,EAClBjQ,EAAK0xB,aAAe1xB,EAAKmQ,eAEzBnQ,EAAKyP,gBAAgB/D,EAAI,EACzB1L,EAAKyP,gBAAgB9D,EAAI,EAEzB3L,EAAKuR,aAAa7F,EAAI1L,EAAK8N,SAASpC,EACpC1L,EAAKuR,aAAa5F,EAAI3L,EAAK8N,SAASnC,EAEpC3L,EAAKyR,UAAYzR,EAAK2M,MACtB3M,EAAK4P,MAAQ,EACb5P,EAAK6P,aAAe,EACpB7P,EAAKkQ,OAAS,EAET2hB,GACD/b,EAAOS,QAAQvW,EAAM,gBAGzBA,EAAKiQ,YAAa,EAClBjQ,EAAK0xB,aAAe,EAEhBG,GACA/b,EAAOS,QAAQvW,EAAM,mBAOlC4qB,WAAW,KAAKkH,IAAI,SAAStjB,EAAQ9uB,EAAOD,IAC/C,SAAWmS,GAYX,GAAI2a,KAEJ7sB,GAAOD,QAAU8sB,CAEjB,IAAIkC,GAAWD,EAAQ,wBACnBtB,EAASsB,EAAQ,kBACjBrC,EAAOqC,EAAQ,gBACfI,EAASJ,EAAQ,sBACjBE,EAASF,EAAQ,sBACjBujB,EAA4B,mBAAXhkC,QAAyBA,OAAA,WAAqC,KAAX6D,EAAyBA,EAAA,OAAmB,MAEpH,WAcI2a,EAAOC,UAAY,SAASd,EAAGC,EAAGrR,EAAOC,EAAQrY,GAC7CA,EAAUA,KAEV,IAAIsqB,IACAjK,MAAO,iBACPuL,UAAYpC,EAAGA,EAAGC,EAAGA,GACrB0D,SAAUZ,EAASa,SAAS,WAAahV,EAAQ,QAAUA,EAAQ,IAAMC,EAAS,QAAUA,GAGhG,IAAIrY,EAAQ8vC,QAAS,CACjB,GAAIA,GAAU9vC,EAAQ8vC,OACtBxlB,GAAU6C,SAAWZ,EAASujB,QAAQxlB,EAAU6C,SAAU2iB,EAAQC,OAC1CD,EAAQE,QAASF,EAAQG,WAAYH,EAAQI,kBAC9DlwC,GAAQ8vC,QAGnB,MAAO7lB,GAAK7c,OAAO4d,EAAO9qB,UAAWoqB,EAAWtqB,KAgBpDqqB,EAAO8lB,UAAY,SAAS3mB,EAAGC,EAAGrR,EAAOC,EAAQ+3B,EAAOpwC,GACpDA,EAAUA,MAEVowC,GAAS,EACT,IAKIC,GALAC,GAAQ,EAAa,EAARF,GAAch4B,EAE3Bm4B,EAAKn4B,EAAQg4B,EACbI,EAAKD,EAAKD,EACVG,EAAKD,EAAKD,CAIVF,GADAD,EAAQ,GACO,WAAaG,EAAK,KAAQl4B,EAAU,MAAQm4B,EAAK,KAAQn4B,EAAU,MAAQo4B,EAAK,KAEhF,WAAaD,EAAK,KAAQn4B,EAAU,MAAQo4B,EAAK,IAGpE,IAAIN,IACA9vB,MAAO,iBACPuL,UAAYpC,EAAGA,EAAGC,EAAGA,GACrB0D,SAAUZ,EAASa,SAASijB,GAGhC,IAAIrwC,EAAQ8vC,QAAS,CACjB,GAAIA,GAAU9vC,EAAQ8vC,OACtBK,GAAUhjB,SAAWZ,EAASujB,QAAQK,EAAUhjB,SAAU2iB,EAAQC,OAC1CD,EAAQE,QAASF,EAAQG,WAAYH,EAAQI,kBAC9DlwC,GAAQ8vC,QAGnB,MAAO7lB,GAAK7c,OAAO4d,EAAO9qB,UAAWiwC,EAAWnwC,KAepDqqB,EAAOqmB,OAAS,SAASlnB,EAAGC,EAAGsmB,EAAQ/vC,EAAS2wC,GAC5C3wC,EAAUA,KAEV,IAAI0wC,IACArwB,MAAO,cACPmS,aAAcud,EAIlBY,GAAWA,GAAY,EACvB,IAAIC,GAAQr8B,KAAK4S,KAAK5S,KAAK6F,IAAI,GAAI7F,KAAKhO,IAAIoqC,EAAUZ,IAMtD,OAHIa,GAAQ,GAAM,IACdA,GAAS,GAENvmB,EAAOwmB,QAAQrnB,EAAGC,EAAGmnB,EAAOb,EAAQ/kB,EAAO9qB,UAAWwwC,EAAQ1wC,KAezEqqB,EAAOwmB,QAAU,SAASrnB,EAAGC,EAAGmnB,EAAOb,EAAQ/vC,GAG3C,GAFAA,EAAUA,MAEN4wC,EAAQ,EACR,MAAOvmB,GAAOqmB,OAAOlnB,EAAGC,EAAGsmB,EAAQ/vC,EAMvC,KAAK,GAJD8wC,GAAQ,EAAIv8B,KAAKmW,GAAKkmB,EACtB7L,EAAO,GACP/R,EAAiB,GAAR8d,EAEJrzC,EAAI,EAAGA,EAAImzC,EAAOnzC,GAAK,EAAG,CAC/B,GAAIgtB,GAAQuI,EAAUv1B,EAAIqzC,EACtBC,EAAKx8B,KAAKyd,IAAIvH,GAASslB,EACvBiB,EAAKz8B,KAAK0d,IAAIxH,GAASslB,CAE3BhL,IAAQ,KAAOgM,EAAGzpB,QAAQ,GAAK,IAAM0pB,EAAG1pB,QAAQ,GAAK,IAGzD,GAAIupB,IACAxwB,MAAO,eACPuL,UAAYpC,EAAGA,EAAGC,EAAGA,GACrB0D,SAAUZ,EAASa,SAAS2X,GAGhC,IAAI/kC,EAAQ8vC,QAAS,CACjB,GAAIA,GAAU9vC,EAAQ8vC,OACtBe,GAAQ1jB,SAAWZ,EAASujB,QAAQe,EAAQ1jB,SAAU2iB,EAAQC,OACtCD,EAAQE,QAASF,EAAQG,WAAYH,EAAQI,kBAC9DlwC,GAAQ8vC,QAGnB,MAAO7lB,GAAK7c,OAAO4d,EAAO9qB,UAAW2wC,EAAS7wC,KAuBlDqqB,EAAO0G,aAAe,SAASvH,EAAGC,EAAGwnB,EAAYjxC,EAASkxC,EAAcC,EAAiBC,GACrF,GAAItzB,GACA1B,EACAi1B,EACAlkB,EACA1vB,EACAuI,EACAmxB,EACAjP,EACAopB,CAkBJ,KAhBAtxC,EAAUA,MACVoc,KAEA80B,MAAuC,KAAjBA,GAA+BA,EACrDC,MAA6C,KAApBA,EAAkCA,EAAkB,IAC7EC,MAAqC,KAAhBA,EAA8BA,EAAc,GAE5DvB,GACD7kB,EAAOjZ,KAAK,wGAIXiZ,EAAOnP,QAAQo1B,EAAW,MAC3BA,GAAcA,IAGb/oB,EAAI,EAAGA,EAAI+oB,EAAWxxC,OAAQyoB,GAAK,EAIpC,GAHAiF,EAAW8jB,EAAW/oB,IACtBmpB,EAAW9kB,EAAS8kB,SAASlkB,MAEZ0iB,EAET1iB,EADAkkB,EACW9kB,EAAS4E,cAAchE,GAGvBZ,EAAS6E,KAAKjE,GAG7B/Q,EAAMzc,MACFisB,UAAYpC,EAAGA,EAAGC,EAAGA,GACrB0D,SAAUA,QAEX,CAEH,GAAIokB,GAAUpkB,EAAS5gB,IAAI,SAAS2pB,GAChC,OAAQA,EAAO1M,EAAG0M,EAAOzM,IAI7BomB,GAAO2B,QAAQD,IACS,IAApBJ,GACAtB,EAAO4B,sBAAsBF,EAASJ,EAG1C,IAAIO,GAAa7B,EAAO8B,YAAYJ,EAGpC,KAAK9zC,EAAI,EAAGA,EAAIi0C,EAAWjyC,OAAQhC,IAAK,CACpC,GAAIm0C,GAAQF,EAAWj0C,GAGnBo0C,EAAgBD,EAAMrlC,IAAI,SAAS4gB,GACnC,OACI3D,EAAG2D,EAAS,GACZ1D,EAAG0D,EAAS,KAKhBikB,GAAc,GAAK7kB,EAASoD,KAAKkiB,GAAiBT,GAItDh1B,EAAMzc,MACFisB,SAAUW,EAASyE,OAAO6gB,GAC1B1kB,SAAU0kB,KAO1B,IAAKp0C,EAAI,EAAGA,EAAI2e,EAAM3c,OAAQhC,IAC1B2e,EAAM3e,GAAKwsB,EAAK7c,OAAO4d,EAAO9qB,OAAOkc,EAAM3e,GAAIuC,GAInD,IAAIkxC,EAAc,CAGd,IAAKzzC,EAAI,EAAGA,EAAI2e,EAAM3c,OAAQhC,IAAK,CAC/B,GAAIy5B,GAAQ9a,EAAM3e,EAElB,KAAKuI,EAAIvI,EAAI,EAAGuI,EAAIoW,EAAM3c,OAAQuG,IAAK,CACnC,GAAIoxB,GAAQhb,EAAMpW,EAElB,IAAI0mB,EAAOuK,SAASC,EAAM9H,OAAQgI,EAAMhI,QAAS,CAC7C,GAAI0iB,GAAM5a,EAAM/J,SACZ4kB,EAAM3a,EAAMjK,QAGhB,KAAKgK,EAAI,EAAGA,EAAID,EAAM/J,SAAS1tB,OAAQ03B,IACnC,IAAKma,EAAI,EAAGA,EAAIla,EAAMjK,SAAS1tB,OAAQ6xC,IAAK,CAExC,GAAIU,GAAKxlB,EAAOylB,iBAAiBzlB,EAAOiF,IAAIqgB,GAAK3a,EAAI,GAAK2a,EAAIryC,QAASsyC,EAAIT,KACvEY,EAAK1lB,EAAOylB,iBAAiBzlB,EAAOiF,IAAIqgB,EAAI3a,GAAI4a,GAAKT,EAAI,GAAKS,EAAItyC,SAGlEuyC,GApBE,GAoB0BE,EApB1B,IAqBFJ,EAAI3a,GAAGgb,YAAa,EACpBJ,EAAIT,GAAGa,YAAa,OAUhD,MAAI/1B,GAAM3c,OAAS,GAEfqe,EAAOmM,EAAK7c,OAAO4d,EAAO9qB,QAASkc,MAAOA,EAAM9b,MAAM,IAAMN,IAC5DiqB,EAAKoG,YAAYvS,GAAQ0L,EAAGA,EAAGC,EAAGA,IAE3B3L,GAEA1B,EAAM,SAMtBze,KAAKgG,SAAuB,KAAX+L,EAAyBA,EAAyB,mBAAT3C,MAAuBA,KAAyB,mBAAXlB,QAAyBA,aACxHu8B,eAAe,EAAEhV,iBAAiB,GAAGG,qBAAqB,GAAGC,qBAAqB,GAAGC,uBAAuB,KAAK2e,IAAI,SAAS9lB,EAAQ9uB,EAAOD,GAUhJ,GAAI80C,KAEJ70C,GAAOD,QAAU80C,CAEjB,IAAIxmB,GAAYS,EAAQ,qBACpBoV,EAAapV,EAAQ,4BACrBtB,EAASsB,EAAQ,kBACjBrC,EAAOqC,EAAQ,gBACfjC,EAASiC,EAAQ,aAErB,WAeI+lB,EAAW3yC,MAAQ,SAASqxC,EAAIC,EAAIsB,EAASC,EAAMC,EAAWC,EAAQnnC,GAOlE,IAAK,GAHDonC,GAHAhzC,EAAQmsB,EAAUze,QAASiT,MAAO,UAClCmJ,EAAIunB,EACJtnB,EAAIunB,EAEJvzC,EAAI,EAECi7B,EAAM,EAAGA,EAAM6Z,EAAM7Z,IAAO,CAGjC,IAAK,GAFDia,GAAY,EAEPjwB,EAAS,EAAGA,EAAS4vB,EAAS5vB,IAAU,CAC7C,GAAI5E,GAAOxS,EAASke,EAAGC,EAAG/G,EAAQgW,EAAKga,EAAUj1C,EAEjD,IAAIqgB,EAAM,CACN,GAAI80B,GAAa90B,EAAKsR,OAAOhV,IAAIqP,EAAI3L,EAAKsR,OAAO7oB,IAAIkjB,EACjDopB,EAAY/0B,EAAKsR,OAAOhV,IAAIoP,EAAI1L,EAAKsR,OAAO7oB,IAAIijB,CAEhDopB,GAAaD,IACbA,EAAYC,GAEhB3oB,EAAKgH,UAAUnT,GAAQ0L,EAAe,GAAZqpB,EAAiBppB,EAAgB,GAAbmpB,IAE9CppB,EAAI1L,EAAKsR,OAAOhV,IAAIoP,EAAIgpB,EAExB3mB,EAAUhC,QAAQnqB,EAAOoe,GAEzB40B,EAAW50B,EACXrgB,GAAK,MAEL+rB,IAAKgpB,EAIb/oB,GAAKkpB,EAAYF,EACjBjpB,EAAIunB,EAGR,MAAOrxC,IAcX2yC,EAAW1L,MAAQ,SAASrd,EAAWwpB,EAAUC,EAAUC,EAAUC,EAAUjzC,GAG3E,IAAK,GAFD2pB,GAASL,EAAUK,OAEdlsB,EAAI,EAAGA,EAAIksB,EAAOlqB,OAAQhC,IAAK,CACpC,GAAIq5B,GAAQnN,EAAOlsB,EAAI,GACnBs5B,EAAQpN,EAAOlsB,GACfy1C,EAAcpc,EAAM1H,OAAOhV,IAAIqP,EAAIqN,EAAM1H,OAAO7oB,IAAIkjB,EACpD0pB,EAAarc,EAAM1H,OAAOhV,IAAIoP,EAAIsN,EAAM1H,OAAO7oB,IAAIijB,EACnD4pB,EAAcrc,EAAM3H,OAAOhV,IAAIqP,EAAIsN,EAAM3H,OAAO7oB,IAAIkjB,EACpD4pB,EAAatc,EAAM3H,OAAOhV,IAAIoP,EAAIuN,EAAM3H,OAAO7oB,IAAIijB,EAEnDwD,GACA8J,MAAOA,EACPgL,QAAUtY,EAAG2pB,EAAaL,EAAUrpB,EAAGypB,EAAcH,GACrDhc,MAAOA,EACPgL,QAAUvY,EAAG6pB,EAAaL,EAAUvpB,EAAG2pB,EAAcH,IAGrDze,EAAaxJ,EAAO9qB,OAAO8sB,EAAUhtB,EAEzC6rB,GAAUyI,cAAchL,EAAWoY,EAAWt0B,OAAOonB,IAKzD,MAFAlL,GAAUjJ,OAAS,SAEZiJ,GAaX+oB,EAAWiB,KAAO,SAAShqB,EAAWgpB,EAASC,EAAMgB,EAAYvzC,GAC7D,GACI04B,GACAD,EACA3B,EACAC,EACAyc,EALA7pB,EAASL,EAAUK,MAOvB,KAAK+O,EAAM,EAAGA,EAAM6Z,EAAM7Z,IAAO,CAC7B,IAAKD,EAAM,EAAGA,EAAM6Z,EAAS7Z,IACzB3B,EAAQnN,EAAQ8O,EAAM,EAAMC,EAAM4Z,GAClCvb,EAAQpN,EAAO8O,EAAOC,EAAM4Z,GAC5BzmB,EAAUyI,cAAchL,EAAWoY,EAAWt0B,OAAO4d,EAAO9qB,QAAS42B,MAAOA,EAAOC,MAAOA,GAAS/2B,IAGvG,IAAI04B,EAAM,EACN,IAAKD,EAAM,EAAGA,EAAM6Z,EAAS7Z,IACzB3B,EAAQnN,EAAO8O,GAAQC,EAAM,GAAK4Z,GAClCvb,EAAQpN,EAAO8O,EAAOC,EAAM4Z,GAC5BzmB,EAAUyI,cAAchL,EAAWoY,EAAWt0B,OAAO4d,EAAO9qB,QAAS42B,MAAOA,EAAOC,MAAOA,GAAS/2B,KAE/FuzC,GAAc9a,EAAM,IACpB+a,EAAQ7pB,EAAQ8O,EAAM,GAAOC,EAAM,GAAK4Z,GACxCzmB,EAAUyI,cAAchL,EAAWoY,EAAWt0B,OAAO4d,EAAO9qB,QAAS42B,MAAO0c,EAAOzc,MAAOA,GAAS/2B,MAGnGuzC,GAAc9a,EAAM6Z,EAAU,IAC9BkB,EAAQ7pB,EAAQ8O,EAAM,GAAOC,EAAM,GAAK4Z,GACxCzmB,EAAUyI,cAAchL,EAAWoY,EAAWt0B,OAAO4d,EAAO9qB,QAAS42B,MAAO0c,EAAOzc,MAAOA,GAAS/2B,MAQnH,MAFAspB,GAAUjJ,OAAS,QAEZiJ,GAgBX+oB,EAAWoB,QAAU,SAAS1C,EAAIC,EAAIsB,EAASC,EAAMC,EAAWC,EAAQnnC,GACpE,MAAO+mC,GAAW3yC,MAAMqxC,EAAIC,EAAIsB,EAASC,EAAMC,EAAWC,EAAQ,SAASjpB,EAAGC,EAAG/G,EAAQgW,EAAKga,EAAUj1C,GACpG,GAAIi2C,GAAan/B,KAAKhO,IAAIgsC,EAAMh+B,KAAK4S,KAAKmrB,EAAU,IAChDqB,EAAgBjB,EAAWA,EAAStjB,OAAOhV,IAAIoP,EAAIkpB,EAAStjB,OAAO7oB,IAAIijB,EAAI,CAE/E,MAAIkP,EAAMgb,GAAV,CAIAhb,EAAMgb,EAAahb,CAEnB,IAAIqW,GAAQrW,EACRuM,EAAMqN,EAAU,EAAI5Z,CAExB,MAAIhW,EAASqsB,GAASrsB,EAASuiB,GAA/B,CAIU,IAANxnC,GACAwsB,EAAKgH,UAAUyhB,GAAYlpB,GAAI9G,GAAU4vB,EAAU,GAAM,EAAI,GAAK,IAAMqB,EAAelqB,EAAG,GAK9F,OAAOne,GAASylC,GAFF2B,EAAWhwB,EAASixB,EAAgB,GAEnBjxB,EAAS8vB,EAAW/oB,EAAG/G,EAAQgW,EAAKga,EAAUj1C,QAcrF40C,EAAWuB,cAAgB,SAAS7C,EAAIC,EAAIrF,EAAQkI,EAAMp0C,GAGtD,IAAK,GAFDm0C,GAAgB/nB,EAAUze,QAASiT,MAAO,mBAErC5iB,EAAI,EAAGA,EAAIkuC,EAAQluC,IAAK,CAC7B,GACIizC,GAASrmB,EAAOqmB,OAAOK,EAAKtzC,GADf,IACoBo2C,GAAoB7C,EAAKvxC,EAAQo0C,GACpDhkB,QAASgB,IAAU1C,YAAa,EAAG5D,SAAU,EAAGC,YAAa,KAAQgE,KAAM,IACzFgG,EAAakN,EAAWt0B,QAAS00B,QAAUtY,EAAGunB,EAAKtzC,GAHtC,IAG2Co2C,GAAoBpqB,EAAGunB,GAAMja,MAAO2Z,GAEhG7kB,GAAUhC,QAAQ+pB,EAAelD,GACjC7kB,EAAUyI,cAAcsf,EAAepf,GAG3C,MAAOof,IAaXvB,EAAWyB,IAAM,SAAS/C,EAAIC,EAAI54B,EAAOC,EAAQ07B,GAC7C,GAAIxlB,GAAQtE,EAAK+E,WAAU,GAEvBglB,EAAwB,IAAR57B,EADJ,GAEZ67B,EAAuB,GAAR77B,EAFH,GAKZ07B,EAAMjoB,EAAUze,QAASiT,MAAO,QAChCvC,EAAOuM,EAAOC,UAAUymB,EAAIC,EAAI54B,EAAOC,GACnCgW,iBACIE,MAAOA,GAEXuhB,SACIC,OAAiB,GAAT13B,GAEZ6V,QAAS,OAGbgmB,EAAS7pB,EAAOqmB,OAAOK,EAAKiD,EAAchD,EAb3B,EAa8C+C,GAC7D1lB,iBACIE,MAAOA,GAEXhE,SAAU,KAGV4pB,EAAS9pB,EAAOqmB,OAAOK,EAAKkD,EAAcjD,EApB3B,EAoB8C+C,GAC7D1lB,iBACIE,MAAOA,GAEXhE,SAAU,KAGV6pB,EAAQ1S,EAAWt0B,QACnB2pB,MAAOjZ,EACPikB,QAAUvY,EAAGwqB,EAAcvqB,EA7BZ,GA8BfqN,MAAOod,EACPhS,UAAW,EACXziC,OAAQ,IAGR40C,EAAQ3S,EAAWt0B,QACnB2pB,MAAOjZ,EACPikB,QAAUvY,EAAGyqB,EAAcxqB,EArCZ,GAsCfqN,MAAOqd,EACPjS,UAAW,EACXziC,OAAQ,GASZ,OANAosB,GAAUhC,QAAQiqB,EAAKh2B,GACvB+N,EAAUhC,QAAQiqB,EAAKI,GACvBroB,EAAUhC,QAAQiqB,EAAKK,GACvBtoB,EAAUyI,cAAcwf,EAAKM,GAC7BvoB,EAAUyI,cAAcwf,EAAKO,GAEtBP,GAkBXzB,EAAWiC,SAAW,SAASvD,EAAIC,EAAIsB,EAASC,EAAMC,EAAWC,EAAQc,EAAYgB,EAAgBC,EAAiBC,GAClHD,EAAkBxpB,EAAO9qB,QAAS2vB,QAASgB,KAAY2jB,GACvDC,EAAoBzpB,EAAO9qB,QAASgiC,UAAW,GAAKr6B,QAAUjE,KAAM,OAAQ2+B,SAAS,IAAWkS,EAEhG,IAAIH,GAAWjC,EAAW3yC,MAAMqxC,EAAIC,EAAIsB,EAASC,EAAMC,EAAWC,EAAQ,SAASjpB,EAAGC,GAClF,MAAOY,GAAOqmB,OAAOlnB,EAAGC,EAAG8qB,EAAgBC,IAO/C,OAJAnC,GAAWiB,KAAKgB,EAAUhC,EAASC,EAAMgB,EAAYkB,GAErDH,EAASj0B,MAAQ,YAEVi0B,QAKZlM,eAAe,EAAEhE,oBAAoB,EAAEtO,2BAA2B,GAAG1C,iBAAiB,GAAGshB,WAAW,KAAKC,IAAI,SAASroB,EAAQ9uB,EAAOD,GAOxI,GAAIovB,KAEJnvB,GAAOD,QAAUovB,CAEjB,IAAIH,GAASF,EAAQ,sBACjBtB,EAASsB,EAAQ,mBAErB,WAQIK,EAAKoE,aAAe,SAAS5D,GAIzB,IAAK,GAHDsC,MAGKhyB,EAAI,EAAGA,EAAI0vB,EAAS1tB,OAAQhC,IAAK,CACtC,GAAIuI,IAAKvI,EAAI,GAAK0vB,EAAS1tB,OACvB89B,EAAS/Q,EAAOooB,WACZprB,EAAG2D,EAASnnB,GAAGyjB,EAAI0D,EAAS1vB,GAAGgsB,EAC/BA,EAAG0D,EAAS1vB,GAAG+rB,EAAI2D,EAASnnB,GAAGwjB,IAEnCqrB,EAAyB,IAAbtX,EAAO9T,EAAWoH,IAAY0M,EAAO/T,EAAI+T,EAAO9T,CAGhEorB,GAAWA,EAASvtB,QAAQ,GAAGvT,WAC/B0b,EAAKolB,GAAYtX,EAGrB,MAAOvS,GAAOpZ,OAAO6d,IASzB9C,EAAK6C,OAAS,SAASC,EAAMhF,GACzB,GAAc,IAAVA,EAMJ,IAAK,GAHDuH,GAAMzd,KAAKyd,IAAIvH,GACfwH,EAAM1d,KAAK0d,IAAIxH,GAEVhtB,EAAI,EAAGA,EAAIgyB,EAAKhwB,OAAQhC,IAAK,CAClC,GACIszC,GADAvQ,EAAO/Q,EAAKhyB,EAEhBszC,GAAKvQ,EAAKhX,EAAIwI,EAAMwO,EAAK/W,EAAIwI,EAC7BuO,EAAK/W,EAAI+W,EAAKhX,EAAIyI,EAAMuO,EAAK/W,EAAIuI,EACjCwO,EAAKhX,EAAIunB,SAMlB3d,iBAAiB,GAAGI,qBAAqB,KAAKshB,IAAI,SAASxoB,EAAQ9uB,EAAOD,GAO7E,GAAImvB,KAEJlvB,GAAOD,QAAUmvB,EAEjB,WAQIA,EAAOtf,OAAS,SAAS+f,GACrB,GAAIiC,IACA7oB,KAAOijB,EAAG,EAAGC,EAAG,GAChBrP,KAAOoP,EAAG,EAAGC,EAAG,GAMpB,OAHI0D,IACAT,EAAOgD,OAAON,EAAQjC,GAEnBiC,GAUX1C,EAAOgD,OAAS,SAASN,EAAQjC,EAAUS,GACvCwB,EAAO7oB,IAAIijB,EAAIqH,IACfzB,EAAOhV,IAAIoP,GAAKqH,IAChBzB,EAAO7oB,IAAIkjB,EAAIoH,IACfzB,EAAOhV,IAAIqP,GAAKoH,GAEhB,KAAK,GAAIpzB,GAAI,EAAGA,EAAI0vB,EAAS1tB,OAAQhC,IAAK,CACtC,GAAIy4B,GAAS/I,EAAS1vB,EAClBy4B,GAAO1M,EAAI4F,EAAOhV,IAAIoP,IAAG4F,EAAOhV,IAAIoP,EAAI0M,EAAO1M,GAC/C0M,EAAO1M,EAAI4F,EAAO7oB,IAAIijB,IAAG4F,EAAO7oB,IAAIijB,EAAI0M,EAAO1M,GAC/C0M,EAAOzM,EAAI2F,EAAOhV,IAAIqP,IAAG2F,EAAOhV,IAAIqP,EAAIyM,EAAOzM,GAC/CyM,EAAOzM,EAAI2F,EAAO7oB,IAAIkjB,IAAG2F,EAAO7oB,IAAIkjB,EAAIyM,EAAOzM,GAGnDmE,IACIA,EAASpE,EAAI,EACb4F,EAAOhV,IAAIoP,GAAKoE,EAASpE,EAEzB4F,EAAO7oB,IAAIijB,GAAKoE,EAASpE,EAGzBoE,EAASnE,EAAI,EACb2F,EAAOhV,IAAIqP,GAAKmE,EAASnE,EAEzB2F,EAAO7oB,IAAIkjB,GAAKmE,EAASnE,IAYrCiD,EAAOiQ,SAAW,SAASvN,EAAQ2C,GAC/B,MAAOA,GAAMvI,GAAK4F,EAAO7oB,IAAIijB,GAAKuI,EAAMvI,GAAK4F,EAAOhV,IAAIoP,GAC9CuI,EAAMtI,GAAK2F,EAAO7oB,IAAIkjB,GAAKsI,EAAMtI,GAAK2F,EAAOhV,IAAIqP,GAU/DiD,EAAOuK,SAAW,SAAS8d,EAASC,GAChC,MAAQD,GAAQxuC,IAAIijB,GAAKwrB,EAAQ56B,IAAIoP,GAAKurB,EAAQ36B,IAAIoP,GAAKwrB,EAAQzuC,IAAIijB,GAC5DurB,EAAQ36B,IAAIqP,GAAKurB,EAAQzuC,IAAIkjB,GAAKsrB,EAAQxuC,IAAIkjB,GAAKurB,EAAQ56B,IAAIqP,GAS9EiD,EAAOuE,UAAY,SAAS7B,EAAQ6lB,GAChC7lB,EAAO7oB,IAAIijB,GAAKyrB,EAAOzrB,EACvB4F,EAAOhV,IAAIoP,GAAKyrB,EAAOzrB,EACvB4F,EAAO7oB,IAAIkjB,GAAKwrB,EAAOxrB,EACvB2F,EAAOhV,IAAIqP,GAAKwrB,EAAOxrB,GAS3BiD,EAAOlL,MAAQ,SAAS4N,EAAQxD,GAC5B,GAAIspB,GAAS9lB,EAAOhV,IAAIoP,EAAI4F,EAAO7oB,IAAIijB,EACnC2rB,EAAS/lB,EAAOhV,IAAIqP,EAAI2F,EAAO7oB,IAAIkjB,CAEvC2F,GAAO7oB,IAAIijB,EAAIoC,EAASpC,EACxB4F,EAAOhV,IAAIoP,EAAIoC,EAASpC,EAAI0rB,EAC5B9lB,EAAO7oB,IAAIkjB,EAAImC,EAASnC,EACxB2F,EAAOhV,IAAIqP,EAAImC,EAASnC,EAAI0rB,WAK9BC,IAAI,SAAS9oB,EAAQ9uB,EAAOD,GAWlC,GAAI83C,KAEJ73C,GAAOD,QAAU83C,CAEJ/oB,GAAQ,uBAErB,WAYI+oB,EAAIC,eAAiB,SAASvQ,EAAMwQ,GAEhC,GAAI93C,GAAG+3C,EAAIlkB,EAAOS,EAAO0jB,EAASC,EAC9BC,EAAeC,EACfC,EAAWC,EACXC,EAAIC,EADqBC,KACjBx2C,EAAS,EAAG+pB,EAAI,EAAGC,EAAI,CAEnC8rB,GAAeA,GAAgB,EAE/B,IAAIW,GAAW,SAASC,EAAIC,EAAIC,GAE5B,GAAIC,GAAaD,EAAc,GAAM,GAAKA,EAAc,CAGxD,KAAKR,GAAaM,GAAMN,EAAUrsB,GAAK4sB,GAAMP,EAAUpsB,EAAG,CAClDosB,GAAaS,GACbP,EAAKF,EAAUrsB,EACfwsB,EAAKH,EAAUpsB,IAEfssB,EAAK,EACLC,EAAK,EAGT,IAAIjkB,IACAvI,EAAGusB,EAAKI,EACR1sB,EAAGusB,EAAKI,IAIRE,GAAeT,IACfA,EAAY9jB,GAGhBkkB,EAAOt2C,KAAKoyB,GAEZvI,EAAIusB,EAAKI,EACT1sB,EAAIusB,EAAKI,IAIbG,EAAkB,SAASd,GAC3B,GAAIe,GAAUf,EAAQgB,oBAAoBC,aAG1C,IAAgB,MAAZF,EAAJ,CAIA,OAAQA,GAER,IAAK,IACL,IAAK,IACL,IAAK,IACL,IAAK,IACL,IAAK,IACL,IAAK,IACDhtB,EAAIisB,EAAQjsB,EACZC,EAAIgsB,EAAQhsB,CACZ,MACJ,KAAK,IACDD,EAAIisB,EAAQjsB,CACZ,MACJ,KAAK,IACDC,EAAIgsB,EAAQhsB,EAIhBysB,EAAS1sB,EAAGC,EAAGgsB,EAAQY,cAW3B,KAPAhB,EAAIsB,mBAAmB5R,GAGvBzT,EAAQyT,EAAK6R,iBAGblB,KACKj4C,EAAI,EAAGA,EAAIsnC,EAAK8R,YAAYC,cAAer5C,GAAK,EACjDi4C,EAAS/1C,KAAKolC,EAAK8R,YAAYE,QAAQt5C,GAK3C,KAHAk4C,EAAgBD,EAAStpC,SAGlB3M,EAAS6xB,GAAO,CAMnB,GAJAwkB,EAAe/Q,EAAKiS,mBAAmBv3C,IACvCg2C,EAAUC,EAASI,KAGJF,EAAa,CACxB,KAAOD,EAAcl2C,QAAUk2C,EAAc,IAAMF,GAC/Cc,EAAgBZ,EAAcn0B,QAElCo0B,GAAcH,EAKlB,OAAQA,EAAQgB,oBAAoBC,eAEpC,IAAK,IACL,IAAK,IACL,IAAK,IACL,IAAK,IACL,IAAK,IACD3kB,EAAQgT,EAAKkS,iBAAiBx3C,GAC9By2C,EAASnkB,EAAMvI,EAAGuI,EAAMtI,EAAG,GAM/BhqB,GAAU81C,EAId,IAAK93C,EAAI,EAAG+3C,EAAKG,EAAcl2C,OAAQhC,EAAI+3C,IAAM/3C,EAC7C84C,EAAgBZ,EAAcl4C,GAElC,OAAOw4C,IAGXZ,EAAIsB,mBAAqB,SAAS5R,GAQ9B,IAAK,GAHDmS,GAAIC,EAAI5G,EAAI6G,EAAI5G,EAAI6G,EAAIC,EAAOvS,EAAK8R,YACpCrtB,EAAI,EAAGC,EAAI,EAAGjjB,EAAM8wC,EAAKR,cAEpBr5C,EAAI,EAAGA,EAAI+I,IAAO/I,EAAG,CAC1B,GAAI85C,GAAMD,EAAKP,QAAQt5C,GACnB+4C,EAAUe,EAAId,mBAElB,IAAI,cAAch0C,KAAK+zC,GACf,KAAOe,KAAK/tB,EAAI+tB,EAAI/tB,GACpB,KAAO+tB,KAAK9tB,EAAI8tB,EAAI9tB,OASxB,QAPI,MAAQ8tB,KAAKhH,EAAK/mB,EAAI+tB,EAAIhH,IAC1B,MAAQgH,KAAK/G,EAAKhnB,EAAI+tB,EAAI/G,IAC1B,MAAQ+G,KAAKH,EAAK3tB,EAAI8tB,EAAIH,IAC1B,MAAQG,KAAKF,EAAK5tB,EAAI8tB,EAAIF,IAC1B,KAAOE,KAAK/tB,GAAK+tB,EAAI/tB,GACrB,KAAO+tB,KAAK9tB,GAAK8tB,EAAI9tB,GAEjB+sB,GAER,IAAK,IACDc,EAAKE,YAAYzS,EAAK0S,0BAA0BjuB,EAAGC,GAAIhsB,EACvD,MACJ,KAAK,IACD65C,EAAKE,YAAYzS,EAAK2S,0BAA0BluB,EAAGC,GAAIhsB,EACvD,MACJ,KAAK,IACD65C,EAAKE,YAAYzS,EAAK4S,oCAAoCnuB,GAAI/rB,EAC9D,MACJ,KAAK,IACD65C,EAAKE,YAAYzS,EAAK6S,kCAAkCnuB,GAAIhsB,EAC5D,MACJ,KAAK,IACD65C,EAAKE,YAAYzS,EAAK8S,gCAAgCruB,EAAGC,EAAG8mB,EAAI6G,EAAI5G,EAAI6G,GAAK55C,EAC7E,MACJ,KAAK,IACD65C,EAAKE,YAAYzS,EAAK+S,sCAAsCtuB,EAAGC,EAAG+mB,EAAI6G,GAAK55C,EAC3E,MACJ,KAAK,IACD65C,EAAKE,YAAYzS,EAAKgT,oCAAoCvuB,EAAGC,EAAG8mB,EAAI6G,GAAK35C,EACzE,MACJ,KAAK,IACD65C,EAAKE,YAAYzS,EAAKiT,0CAA0CxuB,EAAGC,GAAIhsB,EACvE,MACJ,KAAK,IACD65C,EAAKE,YAAYzS,EAAKkT,uBAAuBzuB,EAAGC,EAAG8tB,EAAIW,GAAIX,EAAIY,GAAIZ,EAAI9sB,MAAO8sB,EAAIa,aAAcb,EAAIc,WAAY56C,EAChH,MACJ,KAAK,IACL,IAAK,IACD+rB,EAAI0tB,EACJztB,EAAI0tB,EAMG,KAAXX,GAA6B,KAAXA,IAClBU,EAAK1tB,EACL2tB,EAAK1tB,UAMlB8J,qBAAqB,KAAK+kB,IAAI,SAAShsB,EAAQ9uB,EAAOD,GAazD,GAAIivB,KAEJhvB,GAAOD,QAAUivB,EAEjB,WASIA,EAAOpf,OAAS,SAASoc,EAAGC,GACxB,OAASD,EAAGA,GAAK,EAAGC,EAAGA,GAAK,IAShC+C,EAAO8C,MAAQ,SAAS2lB,GACpB,OAASzrB,EAAGyrB,EAAOzrB,EAAGC,EAAGwrB,EAAOxrB,IASpC+C,EAAOmF,UAAY,SAASsjB,GACxB,MAAO1gC,MAAKgkC,KAAMtD,EAAOzrB,EAAIyrB,EAAOzrB,EAAMyrB,EAAOxrB,EAAIwrB,EAAOxrB,IAShE+C,EAAOylB,iBAAmB,SAASgD,GAC/B,MAAQA,GAAOzrB,EAAIyrB,EAAOzrB,EAAMyrB,EAAOxrB,EAAIwrB,EAAOxrB,GAWtD+C,EAAOgD,OAAS,SAASylB,EAAQxqB,EAAO+tB,GACpC,GAAIxmB,GAAMzd,KAAKyd,IAAIvH,GAAQwH,EAAM1d,KAAK0d,IAAIxH,EACrC+tB,KAAQA,KACb,IAAIhvB,GAAIyrB,EAAOzrB,EAAIwI,EAAMijB,EAAOxrB,EAAIwI,CAGpC,OAFAumB,GAAO/uB,EAAIwrB,EAAOzrB,EAAIyI,EAAMgjB,EAAOxrB,EAAIuI,EACvCwmB,EAAOhvB,EAAIA,EACJgvB,GAYXhsB,EAAOkF,YAAc,SAASujB,EAAQxqB,EAAOsH,EAAOymB,GAChD,GAAIxmB,GAAMzd,KAAKyd,IAAIvH,GAAQwH,EAAM1d,KAAK0d,IAAIxH,EACrC+tB,KAAQA,KACb,IAAIhvB,GAAIuI,EAAMvI,IAAMyrB,EAAOzrB,EAAIuI,EAAMvI,GAAKwI,GAAOijB,EAAOxrB,EAAIsI,EAAMtI,GAAKwI,EAGvE,OAFAumB,GAAO/uB,EAAIsI,EAAMtI,IAAMwrB,EAAOzrB,EAAIuI,EAAMvI,GAAKyI,GAAOgjB,EAAOxrB,EAAIsI,EAAMtI,GAAKuI,GAC1EwmB,EAAOhvB,EAAIA,EACJgvB,GASXhsB,EAAOooB,UAAY,SAASK,GACxB,GAAItjB,GAAYnF,EAAOmF,UAAUsjB,EACjC,OAAkB,KAAdtjB,GACSnI,EAAG,EAAGC,EAAG,IACbD,EAAGyrB,EAAOzrB,EAAImI,EAAWlI,EAAGwrB,EAAOxrB,EAAIkI,IAUpDnF,EAAOuR,IAAM,SAAS0a,EAASC,GAC3B,MAAQD,GAAQjvB,EAAIkvB,EAAQlvB,EAAMivB,EAAQhvB,EAAIivB,EAAQjvB,GAU1D+C,EAAO6R,MAAQ,SAASoa,EAASC,GAC7B,MAAQD,GAAQjvB,EAAIkvB,EAAQjvB,EAAMgvB,EAAQhvB,EAAIivB,EAAQlvB,GAW1DgD,EAAOmsB,OAAS,SAASF,EAASC,EAASE,GACvC,OAAQF,EAAQlvB,EAAIivB,EAAQjvB,IAAMovB,EAAQnvB,EAAIgvB,EAAQhvB,IAAMivB,EAAQjvB,EAAIgvB,EAAQhvB,IAAMmvB,EAAQpvB,EAAIivB,EAAQjvB,IAW9GgD,EAAOpC,IAAM,SAASquB,EAASC,EAASF,GAIpC,MAHKA,KAAQA,MACbA,EAAOhvB,EAAIivB,EAAQjvB,EAAIkvB,EAAQlvB,EAC/BgvB,EAAO/uB,EAAIgvB,EAAQhvB,EAAIivB,EAAQjvB,EACxB+uB,GAWXhsB,EAAOiF,IAAM,SAASgnB,EAASC,EAASF,GAIpC,MAHKA,KAAQA,MACbA,EAAOhvB,EAAIivB,EAAQjvB,EAAIkvB,EAAQlvB,EAC/BgvB,EAAO/uB,EAAIgvB,EAAQhvB,EAAIivB,EAAQjvB,EACxB+uB,GAUXhsB,EAAO0G,KAAO,SAAS+hB,EAAQ4D,GAC3B,OAASrvB,EAAGyrB,EAAOzrB,EAAIqvB,EAAQpvB,EAAGwrB,EAAOxrB,EAAIovB,IAUjDrsB,EAAO2G,IAAM,SAAS8hB,EAAQ4D,GAC1B,OAASrvB,EAAGyrB,EAAOzrB,EAAIqvB,EAAQpvB,EAAGwrB,EAAOxrB,EAAIovB,IAUjDrsB,EAAOoS,KAAO,SAASqW,EAAQ6D,GAE3B,MADAA,IAAoB,IAAXA,GAAmB,EAAI,GACvBtvB,EAAGsvB,GAAU7D,EAAOxrB,EAAGA,EAAGqvB,EAAS7D,EAAOzrB,IASvDgD,EAAOoU,IAAM,SAASqU,GAClB,OAASzrB,GAAIyrB,EAAOzrB,EAAGC,GAAIwrB,EAAOxrB,IAUtC+C,EAAO/B,MAAQ,SAASguB,EAASC,GAC7B,MAAOnkC,MAAKwkC,MAAML,EAAQjvB,EAAIgvB,EAAQhvB,EAAGivB,EAAQlvB,EAAIivB,EAAQjvB,IASjEgD,EAAO1e,OACH0e,EAAOpf,SAAUof,EAAOpf,SACxBof,EAAOpf,SAAUof,EAAOpf,SACxBof,EAAOpf,SAAUof,EAAOpf,kBAI1B4rC,IAAI,SAAS1sB,EAAQ9uB,EAAOD,GAWlC,GAAIgvB,KAEJ/uB,GAAOD,QAAUgvB,CAEjB,IAAIC,GAASF,EAAQ,sBACjBtB,EAASsB,EAAQ,mBAErB,WAmBIC,EAASnf,OAAS,SAAS6oC,EAAQn4B,GAG/B,IAAK,GAFDqP,MAEK1vB,EAAI,EAAGA,EAAIw4C,EAAOx2C,OAAQhC,IAAK,CACpC,GAAIs0B,GAAQkkB,EAAOx4C,GACfy4B,GACI1M,EAAGuI,EAAMvI,EACTC,EAAGsI,EAAMtI,EACTnL,MAAO7gB,EACPqgB,KAAMA,EACNq0B,YAAY,EAGpBhlB,GAASxtB,KAAKu2B,GAGlB,MAAO/I,IAYXZ,EAASa,SAAW,SAAS2X,EAAMjnB,GAC/B,GAAIm7B,GAAc,yCACdhD,IAMJ,OAJAlR,GAAKliC,QAAQo2C,EAAa,SAASC,EAAO1vB,EAAGC,GACzCwsB,EAAOt2C,MAAO6pB,EAAGlN,WAAWkN,GAAIC,EAAGnN,WAAWmN,OAG3C8C,EAASnf,OAAO6oC,EAAQn4B,IASnCyO,EAASyE,OAAS,SAAS7D,GAOvB,IAAK,GAJDkR,GACA8G,EACAn/B,EAJA2pB,EAAOpD,EAASoD,KAAKxC,GAAU,GAC/B6D,GAAWxH,EAAG,EAAGC,EAAG,GAKfhsB,EAAI,EAAGA,EAAI0vB,EAAS1tB,OAAQhC,IACjCuI,GAAKvI,EAAI,GAAK0vB,EAAS1tB,OACvB4+B,EAAQ7R,EAAO6R,MAAMlR,EAAS1vB,GAAI0vB,EAASnnB,IAC3Cm/B,EAAO3Y,EAAO0G,KAAK1G,EAAOpC,IAAI+C,EAAS1vB,GAAI0vB,EAASnnB,IAAKq4B,GACzDrN,EAASxE,EAAOpC,IAAI4G,EAAQmU,EAGhC,OAAO3Y,GAAO2G,IAAInC,EAAQ,EAAIrB,IASlCpD,EAAS4sB,KAAO,SAAShsB,GAGrB,IAAK,GAFDisB,IAAY5vB,EAAG,EAAGC,EAAG,GAEhBhsB,EAAI,EAAGA,EAAI0vB,EAAS1tB,OAAQhC,IACjC27C,EAAQ5vB,GAAK2D,EAAS1vB,GAAG+rB,EACzB4vB,EAAQ3vB,GAAK0D,EAAS1vB,GAAGgsB,CAG7B,OAAO+C,GAAO2G,IAAIimB,EAASjsB,EAAS1tB,SAUxC8sB,EAASoD,KAAO,SAASxC,EAAUksB,GAI/B,IAAK,GAHD1pB,GAAO,EACP3pB,EAAImnB,EAAS1tB,OAAS,EAEjBhC,EAAI,EAAGA,EAAI0vB,EAAS1tB,OAAQhC,IACjCkyB,IAASxC,EAASnnB,GAAGwjB,EAAI2D,EAAS1vB,GAAG+rB,IAAM2D,EAASnnB,GAAGyjB,EAAI0D,EAAS1vB,GAAGgsB,GACvEzjB,EAAIvI,CAGR,OAAI47C,GACO1pB,EAAO,EAEXpb,KAAKqd,IAAIjC,GAAQ,GAU5BpD,EAASsD,QAAU,SAAS1C,EAAUyC,GASlC,IAAK,GALDyO,GACAr4B,EAJAszC,EAAY,EACZC,EAAc,EACdrxB,EAAIiF,EAMC5uB,EAAI,EAAGA,EAAI2pB,EAAEzoB,OAAQlB,IAC1ByH,GAAKzH,EAAI,GAAK2pB,EAAEzoB,OAChB4+B,EAAQ9pB,KAAKqd,IAAIpF,EAAO6R,MAAMnW,EAAEliB,GAAIkiB,EAAE3pB,KACtC+6C,GAAajb,GAAS7R,EAAOuR,IAAI7V,EAAEliB,GAAIkiB,EAAEliB,IAAMwmB,EAAOuR,IAAI7V,EAAEliB,GAAIkiB,EAAE3pB,IAAMiuB,EAAOuR,IAAI7V,EAAE3pB,GAAI2pB,EAAE3pB,KAC3Fg7C,GAAelb,CAGnB,OAAQzO,GAAO,GAAM0pB,EAAYC,IAUrChtB,EAAS0E,UAAY,SAAS9D,EAAU8nB,EAAQ4D,GAC5C,GAAIp7C,EACJ,IAAIo7C,EACA,IAAKp7C,EAAI,EAAGA,EAAI0vB,EAAS1tB,OAAQhC,IAC7B0vB,EAAS1vB,GAAG+rB,GAAKyrB,EAAOzrB,EAAIqvB,EAC5B1rB,EAAS1vB,GAAGgsB,GAAKwrB,EAAOxrB,EAAIovB,MAGhC,KAAKp7C,EAAI,EAAGA,EAAI0vB,EAAS1tB,OAAQhC,IAC7B0vB,EAAS1vB,GAAG+rB,GAAKyrB,EAAOzrB,EACxB2D,EAAS1vB,GAAGgsB,GAAKwrB,EAAOxrB,CAIhC,OAAO0D,IAUXZ,EAASiD,OAAS,SAASrC,EAAU1C,EAAOsH,GACxC,GAAc,IAAVtH,EAAJ,CAMA,IAAK,GAHDuH,GAAMzd,KAAKyd,IAAIvH,GACfwH,EAAM1d,KAAK0d,IAAIxH,GAEVhtB,EAAI,EAAGA,EAAI0vB,EAAS1tB,OAAQhC,IAAK,CACtC,GAAI+7C,GAAUrsB,EAAS1vB,GACnBy0B,EAAKsnB,EAAQhwB,EAAIuI,EAAMvI,EACvB2I,EAAKqnB,EAAQ/vB,EAAIsI,EAAMtI,CAE3B+vB,GAAQhwB,EAAIuI,EAAMvI,GAAK0I,EAAKF,EAAMG,EAAKF,GACvCunB,EAAQ/vB,EAAIsI,EAAMtI,GAAKyI,EAAKD,EAAME,EAAKH,GAG3C,MAAO7E,KAUXZ,EAASoQ,SAAW,SAASxP,EAAU4E,GACnC,IAAK,GAAIt0B,GAAI,EAAGA,EAAI0vB,EAAS1tB,OAAQhC,IAAK,CACtC,GAAI+7C,GAAUrsB,EAAS1vB,GACnBg8C,EAActsB,GAAU1vB,EAAI,GAAK0vB,EAAS1tB,OAC9C,KAAKsyB,EAAMvI,EAAIgwB,EAAQhwB,IAAMiwB,EAAYhwB,EAAI+vB,EAAQ/vB,IAAMsI,EAAMtI,EAAI+vB,EAAQ/vB,IAAM+vB,EAAQhwB,EAAIiwB,EAAYjwB,GAAK,EAC5G,OAAO,EAIf,OAAO,GAWX+C,EAASb,MAAQ,SAASyB,EAAUiF,EAAQC,EAAQN,GAChD,GAAe,IAAXK,GAA2B,IAAXC,EAChB,MAAOlF,EAEX4E,GAAQA,GAASxF,EAASyE,OAAO7D,EAKjC,KAAK,GAHD+I,GACA1E,EAEK/zB,EAAI,EAAGA,EAAI0vB,EAAS1tB,OAAQhC,IACjCy4B,EAAS/I,EAAS1vB,GAClB+zB,EAAQhF,EAAOiF,IAAIyE,EAAQnE,GAC3B5E,EAAS1vB,GAAG+rB,EAAIuI,EAAMvI,EAAIgI,EAAMhI,EAAI4I,EACpCjF,EAAS1vB,GAAGgsB,EAAIsI,EAAMtI,EAAI+H,EAAM/H,EAAI4I,CAGxC,OAAOlF,IAaXZ,EAASujB,QAAU,SAAS3iB,EAAU4iB,EAAQC,EAASC,EAAYC,GAE3DH,EADkB,gBAAXA,IACGA,GAEDA,IAAW,GAIxBC,MAA8B,KAAZA,EAA2BA,GAAW,EACxDC,EAAaA,GAAc,EAC3BC,EAAaA,GAAc,EAI3B,KAAK,GAFDwJ,MAEKj8C,EAAI,EAAGA,EAAI0vB,EAAS1tB,OAAQhC,IAAK,CACtC,GAAIk8C,GAAaxsB,EAAS1vB,EAAI,GAAK,EAAIA,EAAI,EAAI0vB,EAAS1tB,OAAS,GAC7Dy2B,EAAS/I,EAAS1vB,GAClBm8C,EAAazsB,GAAU1vB,EAAI,GAAK0vB,EAAS1tB,QACzCo6C,EAAgB9J,EAAOtyC,EAAIsyC,EAAOtwC,OAAShC,EAAIsyC,EAAOtwC,OAAS,EAEnE,IAAsB,IAAlBo6C,EAAJ,CAKA,GAAIC,GAAattB,EAAOooB,WACpBprB,EAAG0M,EAAOzM,EAAIkwB,EAAWlwB,EACzBA,EAAGkwB,EAAWnwB,EAAI0M,EAAO1M,IAGzBuwB,EAAavtB,EAAOooB,WACpBprB,EAAGowB,EAAWnwB,EAAIyM,EAAOzM,EACzBA,EAAGyM,EAAO1M,EAAIowB,EAAWpwB,IAGzBwwB,EAAiBzlC,KAAKgkC,KAAK,EAAIhkC,KAAKqe,IAAIinB,EAAe,IACvDI,EAAeztB,EAAO0G,KAAKlI,EAAOsE,MAAMwqB,GAAaD,GACrDK,EAAY1tB,EAAOooB,UAAUpoB,EAAO0G,KAAK1G,EAAOpC,IAAI0vB,EAAYC,GAAa,KAC7EI,EAAe3tB,EAAOiF,IAAIyE,EAAQ1J,EAAO0G,KAAKgnB,EAAWF,IAEzDI,EAAYpK,GAEC,IAAbA,IAEAoK,EAA4C,KAAhC7lC,KAAKqe,IAAIinB,EAAe,MAGxCO,EAAYpvB,EAAOqU,MAAM+a,EAAWnK,EAAYC,GAG5CkK,EAAY,GAAM,IAClBA,GAAa,EAKjB,KAAK,GAHDC,GAAQ9lC,KAAK+lC,KAAK9tB,EAAOuR,IAAI+b,EAAYC,IACzCjJ,EAAQuJ,EAAQD,EAEXp0C,EAAI,EAAGA,EAAIo0C,EAAWp0C,IAC3B0zC,EAAY/5C,KAAK6sB,EAAOpC,IAAIoC,EAAOgD,OAAOyqB,EAAcnJ,EAAQ9qC,GAAIm0C,QApCpET,GAAY/5C,KAAKu2B,GAwCzB,MAAOwjB,IASXntB,EAAS4E,cAAgB,SAAShE,GAC9B,GAAI6D,GAASzE,EAAS4sB,KAAKhsB,EAM3B,OAJAA,GAASrR,KAAK,SAASslB,EAASC,GAC5B,MAAO7U,GAAO/B,MAAMuG,EAAQoQ,GAAW5U,EAAO/B,MAAMuG,EAAQqQ,KAGzDlU,GASXZ,EAAS8kB,SAAW,SAASlkB,GAIzB,GAEI1vB,GACAuI,EACAmxB,EACAma,EALAiJ,EAAO,EACPh8C,EAAI4uB,EAAS1tB,MAMjB,IAAIlB,EAAI,EACJ,MAAO,KAEX,KAAKd,EAAI,EAAGA,EAAIc,EAAGd,IAYf,GAXAuI,GAAKvI,EAAI,GAAKc,EACd44B,GAAK15B,EAAI,GAAKc,EACd+yC,GAAKnkB,EAASnnB,GAAGwjB,EAAI2D,EAAS1vB,GAAG+rB,IAAM2D,EAASgK,GAAG1N,EAAI0D,EAASnnB,GAAGyjB,GACnE6nB,IAAMnkB,EAASnnB,GAAGyjB,EAAI0D,EAAS1vB,GAAGgsB,IAAM0D,EAASgK,GAAG3N,EAAI2D,EAASnnB,GAAGwjB,GAEhE8nB,EAAI,EACJiJ,GAAQ,EACDjJ,EAAI,IACXiJ,GAAQ,GAGC,IAATA,EACA,OAAO,CAIf,OAAa,KAATA,GAGO,MAUfhuB,EAAS6E,KAAO,SAASjE,GAGrB,GAEI+I,GACAz4B,EAHA+8C,KACAC,IAYJ,KAPAttB,EAAWA,EAAS7sB,MAAM,GAC1B6sB,EAASrR,KAAK,SAASslB,EAASC,GAC5B,GAAInP,GAAKkP,EAAQ5X,EAAI6X,EAAQ7X,CAC7B,OAAc,KAAP0I,EAAWA,EAAKkP,EAAQ3X,EAAI4X,EAAQ5X,IAI1ChsB,EAAI,EAAGA,EAAI0vB,EAAS1tB,OAAQhC,GAAK,EAAG,CAGrC,IAFAy4B,EAAS/I,EAAS1vB,GAEXg9C,EAAMh7C,QAAU,GACb+sB,EAAOmsB,OAAO8B,EAAMA,EAAMh7C,OAAS,GAAIg7C,EAAMA,EAAMh7C,OAAS,GAAIy2B,IAAW,GACjFukB,EAAM76C,KAGV66C,GAAM96C,KAAKu2B,GAIf,IAAKz4B,EAAI0vB,EAAS1tB,OAAS,EAAGhC,GAAK,EAAGA,GAAK,EAAG,CAG1C,IAFAy4B,EAAS/I,EAAS1vB,GAEX+8C,EAAM/6C,QAAU,GACb+sB,EAAOmsB,OAAO6B,EAAMA,EAAM/6C,OAAS,GAAI+6C,EAAMA,EAAM/6C,OAAS,GAAIy2B,IAAW,GACjFskB,EAAM56C,KAGV46C,GAAM76C,KAAKu2B,GAQf,MAHAskB,GAAM56C,MACN66C,EAAM76C,MAEC46C,EAAMpuC,OAAOquC,SAKzBrnB,iBAAiB,GAAGI,qBAAqB,KAAKknB,IAAI,SAASpuB,EAAQ9uB,EAAOD,GAC7E,GAAIm4B,GAASl4B,EAAOD,QAAU+uB,EAAQ,iBAEtCoJ,GAAOzL,KAAOqC,EAAQ,gBACtBoJ,EAAO7J,UAAYS,EAAQ,qBAC3BoJ,EAAOvL,MAAQmC,EAAQ,iBAEvBoJ,EAAOO,QAAU3J,EAAQ,wBACzBoJ,EAAOY,SAAWhK,EAAQ,yBAC1BoJ,EAAOuC,KAAO3L,EAAQ,qBACtBoJ,EAAO4F,MAAQhP,EAAQ,sBACvBoJ,EAAOc,KAAOlK,EAAQ,qBACtBoJ,EAAOsG,MAAQ1P,EAAQ,sBACvBoJ,EAAOoH,SAAWxQ,EAAQ,yBAC1BoJ,EAAOa,IAAMjK,EAAQ,oBAErBoJ,EAAOgM,WAAapV,EAAQ,4BAC5BoJ,EAAO6N,gBAAkBjX,EAAQ,iCAEjCoJ,EAAO1K,OAASsB,EAAQ,kBACxBoJ,EAAOxK,OAASoB,EAAQ,kBACxBoJ,EAAO9B,OAAStH,EAAQ,kBACxBoJ,EAAO8N,MAAQlX,EAAQ,iBACvBoJ,EAAOnK,OAASe,EAAQ,kBACxBoJ,EAAOjJ,SAAWH,EAAQ,oBAC1BoJ,EAAO0T,OAAS9c,EAAQ,kBAGxBoJ,EAAOrL,OAASiC,EAAQ,qBACxBoJ,EAAO2c,WAAa/lB,EAAQ,yBAE5BoJ,EAAO/I,KAAOL,EAAQ,oBACtBoJ,EAAOhJ,OAASJ,EAAQ,sBACxBoJ,EAAO2f,IAAM/oB,EAAQ,mBACrBoJ,EAAOlJ,OAASF,EAAQ,sBACxBoJ,EAAOnJ,SAAWD,EAAQ,wBAE1BoJ,EAAOvK,OAASmB,EAAQ,oBACxBoJ,EAAOilB,WAAaruB,EAAQ,wBAI5BoJ,EAAOvL,MAAMC,IAAMsL,EAAO7J,UAAUzB,IACpCsL,EAAOvL,MAAM2B,OAAS4J,EAAO7J,UAAUC,OACvC4J,EAAOvL,MAAMoK,aAAemB,EAAO7J,UAAU0I,aAC7CmB,EAAOvL,MAAMN,QAAU6L,EAAO7J,UAAUhC,QACxC6L,EAAOvL,MAAMmK,cAAgBoB,EAAO7J,UAAUyI,cAC9CoB,EAAOvL,MAAM+K,MAAQQ,EAAO7J,UAAUqJ,MACtCQ,EAAOxK,OAAOxX,IAAMgiB,EAAOnK,OAAO7X,MAE/B00B,eAAe,EAAEhE,oBAAoB,EAAEiE,gBAAgB,EAAEuS,uBAAuB,EAAEvW,wBAAwB,EAAEiE,oBAAoB,EAAEuS,oBAAoB,EAAEtS,qBAAqB,EAAEuS,qBAAqB,EAAEtS,wBAAwB,GAAGuS,mBAAmB,GAAGjlB,2BAA2B,GAAGklB,gCAAgC,GAAG5nB,iBAAiB,GAAG6nB,iBAAiB,GAAGtlB,iBAAiB,GAAGulB,iBAAiB,GAAGC,kBAAkB,GAAG7W,gBAAgB,GAAG8W,iBAAiB,GAAGC,iBAAiB,GAAGhoB,mBAAmB,GAAGuJ,oBAAoB,GAAG0e,wBAAwB,GAAGhoB,mBAAmB,GAAGC,qBAAqB,GAAGgoB,kBAAkB,GAAG/nB,qBAAqB,GAAGC,uBAAuB,GAAGC,mBAAmB,GAAG8nB,uBAAuB,KAAKC,IAAI,SAASnvB,EAAQ9uB,EAAOD,GAStuB,GAAI4tB,KAEJ3tB,GAAOD,QAAU4tB,CAEjB,IAAIH,GAASsB,EAAQ,kBACjBT,EAAYS,EAAQ,qBACpBI,EAASJ,EAAQ,sBACjBsH,EAAStH,EAAQ,kBACjB2L,EAAO3L,EAAQ,qBACfE,EAASF,EAAQ,sBACjBkX,EAAQlX,EAAQ,kBAEpB,WAEI,GAAIihB,GACAC,CAEkB,oBAAX3hC,UACP0hC,EAAyB1hC,OAAO4hC,uBAAyB5hC,OAAO6hC,6BAC/B7hC,OAAO8hC,0BAA4B9hC,OAAO+hC,yBAC1C,SAAStiC,GAAWO,OAAOT,WAAW,WAAaE,EAAS0f,EAAOvR,QAAW,IAAO,KAEtH+zB,EAAwB3hC,OAAOgiC,sBAAwBhiC,OAAOiiC,yBAC7BjiC,OAAOkiC,4BAA8BliC,OAAOmiC,wBAWjF7iB,EAAO/d,OAAS,SAASpN,GACrB,GAAIgtB,IACAkL,WAAY/M,EACZF,OAAQ,KACR9P,QAAS,KACTuoB,OAAQ,KACRD,MAAO,KACP+K,eAAgB,KAChBxuC,SACIoY,MAAO,IACPC,OAAQ,IACR4xB,WAAY,EACZ5e,WAAY,UACZqwB,oBAAqB,UACrBC,YAAa37C,EAAQovB,OACrBsf,SAAS,EACTtjB,YAAY,EACZwwB,cAAc,EACdC,WAAW,EACXC,gBAAgB,EAChBC,YAAY,EACZC,cAAc,EACdC,gBAAgB,EAChBC,iBAAiB,EACjBC,UAAU,EACVC,eAAe,EACfC,oBAAoB,EACpBC,SAAS,EACTC,aAAa,EACbC,mBAAmB,EACnBC,iBAAiB,EACjBC,mBAAmB,EACnBC,mBAAmB,IAIvB90C,EAASmjB,EAAO9qB,OAAO8sB,EAAUhtB,EAkCrC,OAhCI6H,GAAO67B,SACP77B,EAAO67B,OAAOtrB,MAAQvQ,EAAO7H,QAAQoY,OAASvQ,EAAO67B,OAAOtrB,MAC5DvQ,EAAO67B,OAAOrrB,OAASxQ,EAAO7H,QAAQqY,QAAUxQ,EAAO67B,OAAOrrB,QAGlExQ,EAAO47B,MAAQzjC,EAAQyjC,MACvB57B,EAAOojB,OAASjrB,EAAQirB,OACxBpjB,EAAO67B,OAAS77B,EAAO67B,QAAUkZ,EAAc/0C,EAAO7H,QAAQoY,MAAOvQ,EAAO7H,QAAQqY,QACpFxQ,EAAOzD,QAAUyD,EAAO67B,OAAOmZ,WAAW,MAC1Ch1C,EAAOi1C,YAEPj1C,EAAOunB,OAASvnB,EAAOunB,SACnB7oB,KACIijB,EAAG,EACHC,EAAG,GAEPrP,KACIoP,EAAG3hB,EAAO67B,OAAOtrB,MACjBqR,EAAG5hB,EAAO67B,OAAOrrB,SAIS,IAA9BxQ,EAAO7H,QAAQiqC,YACf9e,EAAO4xB,cAAcl1C,EAAQA,EAAO7H,QAAQiqC,YAG5Cjf,EAAOqa,UAAUx9B,EAAOsT,SACxBtT,EAAOsT,QAAQtW,YAAYgD,EAAO67B,QAC1B77B,EAAO67B,OAAO1hC,YACtBgpB,EAAOrI,IAAI,2FAA4F,QAGpG9a,GAQXsjB,EAAOzX,IAAM,SAAS7L,IAClB,QAAUm1C,GAAKplC,GACX/P,EAAO2mC,eAAiBjB,EAAuByP,GAC/C7xB,EAAOK,MAAM3jB,OASrBsjB,EAAO2jB,KAAO,SAASjnC,GACnB2lC,EAAsB3lC,EAAO2mC,iBAUjCrjB,EAAO4xB,cAAgB,SAASl1C,EAAQoiC,GACpC,GAAIjqC,GAAU6H,EAAO7H,QACjB0jC,EAAS77B,EAAO67B,MAED,UAAfuG,IACAA,EAAagT,EAAevZ,IAGhC1jC,EAAQiqC,WAAaA,EACrBvG,EAAOlgC,aAAa,mBAAoBymC,GACxCvG,EAAOtrB,MAAQpY,EAAQoY,MAAQ6xB,EAC/BvG,EAAOrrB,OAASrY,EAAQqY,OAAS4xB,EACjCvG,EAAOrhC,MAAM+V,MAAQpY,EAAQoY,MAAQ,KACrCsrB,EAAOrhC,MAAMgW,OAASrY,EAAQqY,OAAS,KACvCxQ,EAAOzD,QAAQsnB,MAAMue,EAAYA,IAgBrC9e,EAAO+xB,OAAS,SAASr1C,EAAQusB,EAASpP,EAASm4B,GAC/CA,MAA2B,KAAXA,GAAyBA,EACzC/oB,EAAUpJ,EAAOnP,QAAQuY,GAAWA,GAAWA,GAC/CpP,EAAUA,IACNwE,EAAG,EACHC,EAAG,EASP,KAAK,GALD2F,IACA7oB,KAAOijB,EAAGqH,IAAUpH,EAAGoH,KACvBzW,KAAOoP,GAAIqH,IAAUpH,GAAIoH,MAGpBpzB,EAAI,EAAGA,EAAI22B,EAAQ30B,OAAQhC,GAAK,EAAG,CACxC,GAAIgB,GAAS21B,EAAQ32B,GACjB8I,EAAM9H,EAAO2wB,OAAS3wB,EAAO2wB,OAAO7oB,IAAO9H,EAAO8H,KAAO9H,EAAOmtB,UAAYntB,EAC5E2b,EAAM3b,EAAO2wB,OAAS3wB,EAAO2wB,OAAOhV,IAAO3b,EAAO2b,KAAO3b,EAAOmtB,UAAYntB,CAE5E8H,IAAO6T,IACH7T,EAAIijB,EAAI4F,EAAO7oB,IAAIijB,IACnB4F,EAAO7oB,IAAIijB,EAAIjjB,EAAIijB,GAEnBpP,EAAIoP,EAAI4F,EAAOhV,IAAIoP,IACnB4F,EAAOhV,IAAIoP,EAAIpP,EAAIoP,GAEnBjjB,EAAIkjB,EAAI2F,EAAO7oB,IAAIkjB,IACnB2F,EAAO7oB,IAAIkjB,EAAIljB,EAAIkjB,GAEnBrP,EAAIqP,EAAI2F,EAAOhV,IAAIqP,IACnB2F,EAAOhV,IAAIqP,EAAIrP,EAAIqP,IAK/B,GAAIrR,GAASgX,EAAOhV,IAAIoP,EAAI4F,EAAO7oB,IAAIijB,EAAK,EAAIxE,EAAQwE,EACpDnR,EAAU+W,EAAOhV,IAAIqP,EAAI2F,EAAO7oB,IAAIkjB,EAAK,EAAIzE,EAAQyE,EACrD2zB,EAAav1C,EAAO67B,OAAOrrB,OAC3BglC,EAAYx1C,EAAO67B,OAAOtrB,MAC1BklC,EAAaD,EAAYD,EACzBG,EAAanlC,EAAQC,EACrB+Z,EAAS,EACTC,EAAS,CAGTkrB,GAAaD,EACbjrB,EAASkrB,EAAaD,EAEtBlrB,EAASkrB,EAAaC,EAI1B11C,EAAO7H,QAAQ27C,WAAY,EAG3B9zC,EAAOunB,OAAO7oB,IAAIijB,EAAI4F,EAAO7oB,IAAIijB,EACjC3hB,EAAOunB,OAAOhV,IAAIoP,EAAI4F,EAAO7oB,IAAIijB,EAAIpR,EAAQga,EAC7CvqB,EAAOunB,OAAO7oB,IAAIkjB,EAAI2F,EAAO7oB,IAAIkjB,EACjC5hB,EAAOunB,OAAOhV,IAAIqP,EAAI2F,EAAO7oB,IAAIkjB,EAAIpR,EAASga,EAG1C8qB,IACAt1C,EAAOunB,OAAO7oB,IAAIijB,GAAa,GAARpR,EAAeA,EAAQga,EAAU,GACxDvqB,EAAOunB,OAAOhV,IAAIoP,GAAa,GAARpR,EAAeA,EAAQga,EAAU,GACxDvqB,EAAOunB,OAAO7oB,IAAIkjB,GAAc,GAATpR,EAAgBA,EAASga,EAAU,GAC1DxqB,EAAOunB,OAAOhV,IAAIqP,GAAc,GAATpR,EAAgBA,EAASga,EAAU,IAI9DxqB,EAAOunB,OAAO7oB,IAAIijB,GAAKxE,EAAQwE,EAC/B3hB,EAAOunB,OAAOhV,IAAIoP,GAAKxE,EAAQwE,EAC/B3hB,EAAOunB,OAAO7oB,IAAIkjB,GAAKzE,EAAQyE,EAC/B5hB,EAAOunB,OAAOhV,IAAIqP,GAAKzE,EAAQyE,EAG3B5hB,EAAO47B,QACPD,EAAMiH,SAAS5iC,EAAO47B,OAClBja,GAAI3hB,EAAOunB,OAAOhV,IAAIoP,EAAI3hB,EAAOunB,OAAO7oB,IAAIijB,GAAK3hB,EAAO67B,OAAOtrB,MAC/DqR,GAAI5hB,EAAOunB,OAAOhV,IAAIqP,EAAI5hB,EAAOunB,OAAO7oB,IAAIkjB,GAAK5hB,EAAO67B,OAAOrrB,SAGnEmrB,EAAMgH,UAAU3iC,EAAO47B,MAAO57B,EAAOunB,OAAO7oB,OASpD4kB,EAAOqyB,mBAAqB,SAAS31C,GACjC,GAAI41C,GAAc51C,EAAOunB,OAAOhV,IAAIoP,EAAI3hB,EAAOunB,OAAO7oB,IAAIijB,EACtDk0B,EAAe71C,EAAOunB,OAAOhV,IAAIqP,EAAI5hB,EAAOunB,OAAO7oB,IAAIkjB,EACvDk0B,EAAeF,EAAc51C,EAAO7H,QAAQoY,MAC5CwlC,EAAeF,EAAe71C,EAAO7H,QAAQqY,MAEjDxQ,GAAOzD,QAAQsnB,MAAM,EAAIiyB,EAAc,EAAIC,GAC3C/1C,EAAOzD,QAAQ6sB,WAAWppB,EAAOunB,OAAO7oB,IAAIijB,GAAI3hB,EAAOunB,OAAO7oB,IAAIkjB,IAQtE0B,EAAO0yB,iBAAmB,SAASh2C,GAC/BA,EAAOzD,QAAQ05C,aAAaj2C,EAAO7H,QAAQiqC,WAAY,EAAG,EAAGpiC,EAAO7H,QAAQiqC,WAAY,EAAG,IAS/F9e,EAAOK,MAAQ,SAAS3jB,GACpB,GAUIpK,GAVAwtB,EAASpjB,EAAOojB,OAChBO,EAAQP,EAAOO,MACfkY,EAAS77B,EAAO67B,OAChBt/B,EAAUyD,EAAOzD,QACjBpE,EAAU6H,EAAO7H,QACjBo1B,EAAYvJ,EAAUuJ,UAAU5J,GAChC6J,EAAiBxJ,EAAUwJ,eAAe7J,GAC1CH,EAAarrB,EAAQorB,WAAaprB,EAAQ07C,oBAAsB17C,EAAQqrB,WACxE1B,KACAmK,KAGAjwB,GACAy2B,UAAWrP,EAAOsc,OAAOjN,UAgB7B,IAbA1G,EAAOS,QAAQxsB,EAAQ,eAAgBhE,GAGnCgE,EAAOk2C,oBAAsB1yB,GAC7B2yB,EAAiBn2C,EAAQwjB,GAG7BjnB,EAAQ65C,yBAA2B,YACnC75C,EAAQ6nB,UAAY,cACpB7nB,EAAQ85C,SAAS,EAAG,EAAGxa,EAAOtrB,MAAOsrB,EAAOrrB,QAC5CjU,EAAQ65C,yBAA2B,cAG/Bj+C,EAAQ27C,UAAW,CAEnB,IAAKl+C,EAAI,EAAGA,EAAI23B,EAAU31B,OAAQhC,IAAK,CACnC,GAAIqgB,GAAOsX,EAAU33B,EACjBivB,GAAOuK,SAASnZ,EAAKsR,OAAQvnB,EAAOunB,SACpCzF,EAAOhqB,KAAKme,GAIpB,IAAKrgB,EAAI,EAAGA,EAAI43B,EAAe51B,OAAQhC,IAAK,CACxC,GAAI+2B,GAAaa,EAAe53B,GAC5Bq5B,EAAQtC,EAAWsC,MACnBC,EAAQvC,EAAWuC,MACnB8L,EAAcrO,EAAWsN,OACzBgB,EAActO,EAAWuN,MAEzBjL,KAAO+L,EAAcrW,EAAOpC,IAAI0M,EAAMlL,SAAU4I,EAAWsN,SAC3D/K,IAAO+L,EAActW,EAAOpC,IAAI2M,EAAMnL,SAAU4I,EAAWuN,SAE1Dc,GAAgBC,KAGjBpW,EAAOiQ,SAAS90B,EAAOunB,OAAQyT,IAAgBnW,EAAOiQ,SAAS90B,EAAOunB,OAAQ0T,KAC9EhP,EAAYn0B,KAAK60B,IAIzBrJ,EAAOqyB,mBAAmB31C,GAGtBA,EAAO47B,QACPD,EAAMiH,SAAS5iC,EAAO47B,OAClBja,GAAI3hB,EAAOunB,OAAOhV,IAAIoP,EAAI3hB,EAAOunB,OAAO7oB,IAAIijB,GAAK3hB,EAAO67B,OAAOtrB,MAC/DqR,GAAI5hB,EAAOunB,OAAOhV,IAAIqP,EAAI5hB,EAAOunB,OAAO7oB,IAAIkjB,GAAK5hB,EAAO67B,OAAOrrB,SAGnEmrB,EAAMgH,UAAU3iC,EAAO47B,MAAO57B,EAAOunB,OAAO7oB,UAGhDutB,GAAcuB,EACd1L,EAASyL,GAGRp1B,EAAQorB,YAAeH,EAAOoc,gBAAkBrnC,EAAQ47C,aAEzDzwB,EAAOxB,OAAO9hB,EAAQ8hB,EAAQvlB,IAE1BpE,EAAQy8C,iBACRtxB,EAAOgzB,gBAAgBt2C,EAAQ8hB,EAAQvlB,GAG3C+mB,EAAOizB,eAAev2C,EAAQ8hB,EAAQvlB,IAGtCpE,EAAQ+7C,YACR5wB,EAAOkzB,WAAWx2C,EAAQ8hB,EAAQvlB,IAElCpE,EAAQm8C,UAAYn8C,EAAQq8C,qBAC5BlxB,EAAOmzB,SAASz2C,EAAQ8hB,EAAQvlB,GAEhCpE,EAAQo8C,eACRjxB,EAAOozB,cAAc12C,EAAQ8hB,EAAQvlB,GAErCpE,EAAQg8C,cACR7wB,EAAOqzB,aAAa32C,EAAQ8hB,EAAQvlB,GAEpCpE,EAAQs8C,SACRnxB,EAAOszB,QAAQ52C,EAAQ8hB,EAAQvlB,GAE/BpE,EAAQk8C,iBACR/wB,EAAOuzB,YAAY72C,EAAQojB,EAAO2L,MAAM91B,KAAMsD,GAE9CpE,EAAQi8C,gBACR9wB,EAAOsL,WAAW5uB,EAAQojB,EAAO2L,MAAM91B,KAAMsD,GAE7CpE,EAAQw8C,mBACRrxB,EAAOwzB,cAAc92C,EAAQ8hB,EAAQvlB,GAErCpE,EAAQ28C,mBACRxxB,EAAOyzB,cAAc/2C,EAAQA,EAAO47B,MAAOr/B,GAE/C+mB,EAAO2I,YAAYA,EAAa1vB,GAE5BpE,EAAQ87C,gBAAkB7wB,EAAOuc,WAAWtP,aAAeD,GAC3D9M,EAAOqN,KAAK3wB,EAAQojB,EAAOuc,WAAYpjC,GAEvCpE,EAAQ67C,WACR1wB,EAAO0zB,MAAMh3C,EAAQzD,GAErBpE,EAAQ27C,WAERxwB,EAAO0yB,iBAAiBh2C,GAG5B+rB,EAAOS,QAAQxsB,EAAQ,cAAehE,IAU1CsnB,EAAO0zB,MAAQ,SAASh3C,EAAQzD,GAC5B,GAAIvG,GAAIuG,EACJ6mB,EAASpjB,EAAOojB,OAChBO,EAAQP,EAAOO,MACfkc,EAAUzc,EAAOyc,QACjB1nC,EAAU6H,EAAO7H,OACR6rB,GAAUuJ,UAAU5J,EAGjC,IAAIP,EAAOsc,OAAOjN,WAAazyB,EAAOi3C,gBAAkB,IAAM,IAAK,CAC/D,GAAIC,GAAO,EAEPrX,GAAQH,SACRwX,GAAQ,QAAUxqC,KAAKyqC,MAAMtX,EAAQH,OAAO/hB,KANxC,QAUR3d,EAAOo3C,YAAcF,EACrBl3C,EAAOi3C,eAAiB7zB,EAAOsc,OAAOjN,UAG1C,GAAIzyB,EAAOo3C,YAAa,CACpBphD,EAAEqhD,KAAO,aAELl/C,EAAQorB,WACRvtB,EAAEouB,UAAY,wBAEdpuB,EAAEouB,UAAY,iBAKlB,KAAK,GAFD9P,GAAQtU,EAAOo3C,YAAY9iC,MAAM,MAE5B1e,EAAI,EAAGA,EAAI0e,EAAM1c,OAAQhC,IAC9BI,EAAEshD,SAAShjC,EAAM1e,GAAI,GAAI,GAAS,GAAJA,KAY1C0tB,EAAO2I,YAAc,SAASA,EAAa1vB,GAGvC,IAAK,GAFDvG,GAAIuG,EAEC3G,EAAI,EAAGA,EAAIq2B,EAAYr0B,OAAQhC,IAAK,CACzC,GAAI+2B,GAAaV,EAAYr2B,EAE7B,IAAK+2B,EAAW3sB,OAAO6mB,SAAY8F,EAAWsN,QAAWtN,EAAWuN,OAApE,CAGA,GAEIgN,GACA9J,EAHAnO,EAAQtC,EAAWsC,MACnBC,EAAQvC,EAAWuC,KAUvB,IALIgY,EADAjY,EACQtK,EAAOpC,IAAI0M,EAAMlL,SAAU4I,EAAWsN,QAEtCtN,EAAWsN,OAGQ,QAA3BtN,EAAW3sB,OAAOjE,KAClB/F,EAAEuhD,YACFvhD,EAAEwhD,IAAItQ,EAAMvlB,EAAGulB,EAAMtlB,EAAG,EAAG,EAAG,EAAIlV,KAAKmW,IACvC7sB,EAAEyhD,gBACC,CAUH,GARIra,EADAlO,EACMvK,EAAOpC,IAAI2M,EAAMnL,SAAU4I,EAAWuN,QAEtCvN,EAAWuN,OAGrBlkC,EAAEuhD,YACFvhD,EAAE0hD,OAAOxQ,EAAMvlB,EAAGulB,EAAMtlB,GAEO,WAA3B+K,EAAW3sB,OAAOjE,KAMlB,IAAK,GAFDovB,GAHAxB,EAAQhF,EAAOiF,IAAIwT,EAAK8J,GACxBxR,EAAS/Q,EAAOoS,KAAKpS,EAAOooB,UAAUpjB,IACtCguB,EAAQjrC,KAAK4S,KAAK6D,EAAOqU,MAAM7K,EAAW/0B,OAAS,EAAG,GAAI,KAGrDuG,EAAI,EAAGA,EAAIw5C,EAAOx5C,GAAK,EAC5BgtB,EAAShtB,EAAI,GAAM,EAAI,GAAK,EAE5BnI,EAAE4hD,OACE1Q,EAAMvlB,EAAIgI,EAAMhI,GAAKxjB,EAAIw5C,GAASjiB,EAAO/T,EAAIwJ,EAAS,EACtD+b,EAAMtlB,EAAI+H,EAAM/H,GAAKzjB,EAAIw5C,GAASjiB,EAAO9T,EAAIuJ,EAAS,EAKlEn1B,GAAE4hD,OAAOxa,EAAIzb,EAAGyb,EAAIxb,GAGpB+K,EAAW3sB,OAAOinB,YAClBjxB,EAAEixB,UAAY0F,EAAW3sB,OAAOinB,UAChCjxB,EAAE8sB,YAAc6J,EAAW3sB,OAAO8iB,YAClC9sB,EAAE+pB,UAGF4M,EAAW3sB,OAAO06B,UAClB1kC,EAAEouB,UAAYuI,EAAW3sB,OAAO8iB,YAChC9sB,EAAEuhD,YACFvhD,EAAEwhD,IAAItQ,EAAMvlB,EAAGulB,EAAMtlB,EAAG,EAAG,EAAG,EAAIlV,KAAKmW,IACvC7sB,EAAEwhD,IAAIpa,EAAIzb,EAAGyb,EAAIxb,EAAG,EAAG,EAAG,EAAIlV,KAAKmW,IACnC7sB,EAAEyhD,YACFzhD,EAAEgqB,WAadsD,EAAOu0B,YAAc,SAAS73C,EAAQ8hB,EAAQvlB,GAI1C,IAAK,GAHDvG,GAAIuG,EAGC3G,GAFIoK,EAAOojB,OAEP,GAAGxtB,EAAIksB,EAAOlqB,OAAQhC,IAAK,CACpC,GAAIqgB,GAAO6L,EAAOlsB,EAElB,IAAKqgB,EAAKjW,OAAO6mB,QAAjB,CAGA,GAAI5Q,EAAK0U,aACL30B,EAAEuhD,YACFvhD,EAAEwhD,IAAIvhC,EAAK8N,SAASpC,EAAG1L,EAAK8N,SAASnC,EAAG3L,EAAK0U,aAAc,EAAG,EAAIje,KAAKmW,IACvE7sB,EAAEyhD,gBACC,CACHzhD,EAAEuhD,YACFvhD,EAAE0hD,OAAOzhC,EAAKqP,SAAS,GAAG3D,EAAG1L,EAAKqP,SAAS,GAAG1D,EAC9C,KAAK,GAAIzjB,GAAI,EAAGA,EAAI8X,EAAKqP,SAAS1tB,OAAQuG,IACtCnI,EAAE4hD,OAAO3hC,EAAKqP,SAASnnB,GAAGwjB,EAAG1L,EAAKqP,SAASnnB,GAAGyjB,EAElD5rB,GAAEyhD,YAGN,GAAIK,GAAY7hC,EAAK8N,SAASpC,EAA2B,GAAvB3hB,EAAO7H,QAAQoY,MAC7CwnC,EAAY9hC,EAAK8N,SAASnC,EAA4B,GAAxB5hB,EAAO7H,QAAQqY,OAC7C8oB,EAAW5sB,KAAKqd,IAAI+tB,GAAaprC,KAAKqd,IAAIguB,EAE9C/hD,GAAEgiD,YAAc,mBAChBhiD,EAAEiiD,cAAgB,IAAOH,EACzB9hD,EAAEkiD,cAAgB,IAAOH,EACzB/hD,EAAEmiD,WAAa,EAAI,GAAKzrC,KAAKhO,IAAI,EAAG46B,EAAW,KAE/CtjC,EAAEgqB,OAEFhqB,EAAEgiD,YAAc,KAChBhiD,EAAEiiD,cAAgB,KAClBjiD,EAAEkiD,cAAgB,KAClBliD,EAAEmiD,WAAa,QAYvB70B,EAAOxB,OAAS,SAAS9hB,EAAQ8hB,EAAQvlB,GACrC,GAII0Z,GACA2S,EACAhzB,EACA05B,EAPAt5B,EAAIuG,EAEJpE,GADS6H,EAAOojB,OACNpjB,EAAO7H,SACjB08C,EAAoB18C,EAAQ08C,oBAAsB18C,EAAQorB,UAM9D,KAAK3tB,EAAI,EAAGA,EAAIksB,EAAOlqB,OAAQhC,IAG3B,GAFAqgB,EAAO6L,EAAOlsB,GAETqgB,EAAKjW,OAAO6mB,QAIjB,IAAKyI,EAAIrZ,EAAK1B,MAAM3c,OAAS,EAAI,EAAI,EAAG03B,EAAIrZ,EAAK1B,MAAM3c,OAAQ03B,IAG3D,GAFA1G,EAAO3S,EAAK1B,MAAM+a,GAEb1G,EAAK5oB,OAAO6mB,QAAjB,CASA,GANI1uB,EAAQ47C,cAAgB99B,EAAKiQ,WAC7BlwB,EAAEoiD,YAAc,GAAMxvB,EAAK5oB,OAAO8mB,QACH,IAAxB8B,EAAK5oB,OAAO8mB,UACnB9wB,EAAEoiD,YAAcxvB,EAAK5oB,OAAO8mB,SAG5B8B,EAAK5oB,OAAO+hB,QAAU6G,EAAK5oB,OAAO+hB,OAAOgB,UAAY5qB,EAAQorB,WAAY,CAEzE,GAAIxB,GAAS6G,EAAK5oB,OAAO+hB,OACrBgB,EAAUs1B,EAAYr4C,EAAQ+hB,EAAOgB,QAEzC/sB,GAAEozB,UAAUR,EAAK7E,SAASpC,EAAGiH,EAAK7E,SAASnC,GAC3C5rB,EAAE2xB,OAAOiB,EAAKhG,OAEd5sB,EAAEsiD,UACEv1B,EACAA,EAAQxS,OAASwR,EAAOgF,QAAUhF,EAAOkB,OACzCF,EAAQvS,QAAUuR,EAAOiF,QAAUjF,EAAOmB,OAC1CH,EAAQxS,MAAQwR,EAAOkB,OACvBF,EAAQvS,OAASuR,EAAOmB,QAI5BltB,EAAE2xB,QAAQiB,EAAKhG,OACf5sB,EAAEozB,WAAWR,EAAK7E,SAASpC,GAAIiH,EAAK7E,SAASnC,OAC1C,CAEH,GAAIgH,EAAK+B,aACL30B,EAAEuhD,YACFvhD,EAAEwhD,IAAI5uB,EAAK7E,SAASpC,EAAGiH,EAAK7E,SAASnC,EAAGgH,EAAK+B,aAAc,EAAG,EAAIje,KAAKmW,QACpE,CACH7sB,EAAEuhD,YACFvhD,EAAE0hD,OAAO9uB,EAAKtD,SAAS,GAAG3D,EAAGiH,EAAKtD,SAAS,GAAG1D,EAE9C,KAAK,GAAIzjB,GAAI,EAAGA,EAAIyqB,EAAKtD,SAAS1tB,OAAQuG,KACjCyqB,EAAKtD,SAASnnB,EAAI,GAAGmsC,YAAcuK,EACpC7+C,EAAE4hD,OAAOhvB,EAAKtD,SAASnnB,GAAGwjB,EAAGiH,EAAKtD,SAASnnB,GAAGyjB,GAE9C5rB,EAAE0hD,OAAO9uB,EAAKtD,SAASnnB,GAAGwjB,EAAGiH,EAAKtD,SAASnnB,GAAGyjB,GAG9CgH,EAAKtD,SAASnnB,GAAGmsC,aAAeuK,GAChC7+C,EAAE0hD,OAAO9uB,EAAKtD,UAAUnnB,EAAI,GAAKyqB,EAAKtD,SAAS1tB,QAAQ+pB,EAAGiH,EAAKtD,UAAUnnB,EAAI,GAAKyqB,EAAKtD,SAAS1tB,QAAQgqB,EAIhH5rB,GAAE4hD,OAAOhvB,EAAKtD,SAAS,GAAG3D,EAAGiH,EAAKtD,SAAS,GAAG1D,GAC9C5rB,EAAEyhD,YAGDt/C,EAAQorB,YAWTvtB,EAAEixB,UAAY,EACdjxB,EAAE8sB,YAAc,OAChB9sB,EAAE+pB,WAZF/pB,EAAEouB,UAAYwE,EAAK5oB,OAAOokB,UAEtBwE,EAAK5oB,OAAOinB,YACZjxB,EAAEixB,UAAY2B,EAAK5oB,OAAOinB,UAC1BjxB,EAAE8sB,YAAc8F,EAAK5oB,OAAO8iB,YAC5B9sB,EAAE+pB,UAGN/pB,EAAEgqB,QAQVhqB,EAAEoiD,YAAc,IAa5B90B,EAAOizB,eAAiB,SAASv2C,EAAQ8hB,EAAQvlB,GAC7C,GAEI0Z,GACA2S,EACAhzB,EACAuI,EACAmxB,EANAt5B,EAAIuG,EACJs4C,EAAoB70C,EAAO7H,QAAQ08C,iBAUvC,KAHA7+C,EAAEuhD,YAGG3hD,EAAI,EAAGA,EAAIksB,EAAOlqB,OAAQhC,IAG3B,GAFAqgB,EAAO6L,EAAOlsB,GAETqgB,EAAKjW,OAAO6mB,QAIjB,IAAKyI,EAAIrZ,EAAK1B,MAAM3c,OAAS,EAAI,EAAI,EAAG03B,EAAIrZ,EAAK1B,MAAM3c,OAAQ03B,IAAK,CAKhE,IAJA1G,EAAO3S,EAAK1B,MAAM+a,GAElBt5B,EAAE0hD,OAAO9uB,EAAKtD,SAAS,GAAG3D,EAAGiH,EAAKtD,SAAS,GAAG1D,GAEzCzjB,EAAI,EAAGA,EAAIyqB,EAAKtD,SAAS1tB,OAAQuG,KAC7ByqB,EAAKtD,SAASnnB,EAAI,GAAGmsC,YAAcuK,EACpC7+C,EAAE4hD,OAAOhvB,EAAKtD,SAASnnB,GAAGwjB,EAAGiH,EAAKtD,SAASnnB,GAAGyjB,GAE9C5rB,EAAE0hD,OAAO9uB,EAAKtD,SAASnnB,GAAGwjB,EAAGiH,EAAKtD,SAASnnB,GAAGyjB,GAG9CgH,EAAKtD,SAASnnB,GAAGmsC,aAAeuK,GAChC7+C,EAAE0hD,OAAO9uB,EAAKtD,UAAUnnB,EAAI,GAAKyqB,EAAKtD,SAAS1tB,QAAQ+pB,EAAGiH,EAAKtD,UAAUnnB,EAAI,GAAKyqB,EAAKtD,SAAS1tB,QAAQgqB,EAIhH5rB,GAAE4hD,OAAOhvB,EAAKtD,SAAS,GAAG3D,EAAGiH,EAAKtD,SAAS,GAAG1D,GAItD5rB,EAAEixB,UAAY,EACdjxB,EAAE8sB,YAAc,OAChB9sB,EAAE+pB,UAWNuD,EAAOgzB,gBAAkB,SAASt2C,EAAQ8hB,EAAQvlB,GAC9C,GACI0Z,GAEArgB,EACAuI,EAJAnI,EAAIuG,CAUR,KAHAvG,EAAEuhD,YAGG3hD,EAAI,EAAGA,EAAIksB,EAAOlqB,OAAQhC,IAG3B,GAFAqgB,EAAO6L,EAAOlsB,GAETqgB,EAAKjW,OAAO6mB,SAAiC,IAAtB5Q,EAAK1B,MAAM3c,OAAvC,CAKA,IAFA5B,EAAE0hD,OAAOzhC,EAAKqP,SAAS,GAAG3D,EAAG1L,EAAKqP,SAAS,GAAG1D,GAEzCzjB,EAAI,EAAGA,EAAI8X,EAAKqP,SAAS1tB,OAAQuG,IAClCnI,EAAE4hD,OAAO3hC,EAAKqP,SAASnnB,GAAGwjB,EAAG1L,EAAKqP,SAASnnB,GAAGyjB,EAGlD5rB,GAAE4hD,OAAO3hC,EAAKqP,SAAS,GAAG3D,EAAG1L,EAAKqP,SAAS,GAAG1D,GAGlD5rB,EAAEixB,UAAY,EACdjxB,EAAE8sB,YAAc,wBAChB9sB,EAAE+pB,UAWNuD,EAAOwzB,cAAgB,SAAS92C,EAAQ8hB,EAAQvlB,GAC5C,GACI3G,GACAuI,EACAmxB,EAHAt5B,EAAIuG,CAKR,KAAK3G,EAAI,EAAGA,EAAIksB,EAAOlqB,OAAQhC,IAAK,CAChC,GAAI2e,GAAQuN,EAAOlsB,GAAG2e,KACtB,KAAK+a,EAAI/a,EAAM3c,OAAS,EAAI,EAAI,EAAG03B,EAAI/a,EAAM3c,OAAQ03B,IAAK,CACtD,GAAI1G,GAAOrU,EAAM+a,EACjB,KAAKnxB,EAAI,EAAGA,EAAIyqB,EAAKtD,SAAS1tB,OAAQuG,IAClCnI,EAAEouB,UAAY,wBACdpuB,EAAEshD,SAAS1hD,EAAI,IAAMuI,EAAGyqB,EAAK7E,SAASpC,EAA6C,IAAxCiH,EAAKtD,SAASnnB,GAAGwjB,EAAIiH,EAAK7E,SAASpC,GAAUiH,EAAK7E,SAASnC,EAA6C,IAAxCgH,EAAKtD,SAASnnB,GAAGyjB,EAAIgH,EAAK7E,SAASnC,OAc9J0B,EAAOyzB,cAAgB,SAAS/2C,EAAQ47B,EAAOr/B,GAC3C,GAAIvG,GAAIuG,CACRvG,GAAEouB,UAAY,wBACdpuB,EAAEshD,SAAS1b,EAAM7X,SAASpC,EAAI,KAAOia,EAAM7X,SAASnC,EAAGga,EAAM7X,SAASpC,EAAI,EAAGia,EAAM7X,SAASnC,EAAI,IAWpG0B,EAAOkzB,WAAa,SAASx2C,EAAQ8hB,EAAQvlB,GACzC,GAAIvG,GAAIuG,EAEJpE,GADS6H,EAAOojB,OACNpjB,EAAO7H,QAErBnC,GAAEuhD,WAEF,KAAK,GAAI3hD,GAAI,EAAGA,EAAIksB,EAAOlqB,OAAQhC,IAAK,CAGpC,GAFWksB,EAAOlsB,GAEToK,OAAO6mB,QAEZ,IAAK,GADDtS,GAAQuN,EAAOlsB,GAAG2e,MACbpW,EAAIoW,EAAM3c,OAAS,EAAI,EAAI,EAAGuG,EAAIoW,EAAM3c,OAAQuG,IAAK,CAC1D,GAAIyqB,GAAOrU,EAAMpW,EACjBnI,GAAE6c,KAAK+V,EAAKrB,OAAO7oB,IAAIijB,EAAGiH,EAAKrB,OAAO7oB,IAAIkjB,EAAGgH,EAAKrB,OAAOhV,IAAIoP,EAAIiH,EAAKrB,OAAO7oB,IAAIijB,EAAGiH,EAAKrB,OAAOhV,IAAIqP,EAAIgH,EAAKrB,OAAO7oB,IAAIkjB,IAKhIzpB,EAAQorB,WACRvtB,EAAE8sB,YAAc,yBAEhB9sB,EAAE8sB,YAAc,kBAGpB9sB,EAAEixB,UAAY,EACdjxB,EAAE+pB,UAWNuD,EAAOmzB,SAAW,SAASz2C,EAAQ8hB,EAAQvlB,GACvC,GAGIqsB,GACAhzB,EACAuI,EACAmxB,EANAt5B,EAAIuG,EAEJpE,GADS6H,EAAOojB,OACNpjB,EAAO7H,QAQrB,KAFAnC,EAAEuhD,YAEG3hD,EAAI,EAAGA,EAAIksB,EAAOlqB,OAAQhC,IAAK,CAChC,GAAIqgB,GAAO6L,EAAOlsB,GACd2e,EAAQ0B,EAAK1B,KAEjB,IAAK0B,EAAKjW,OAAO6mB,QAGjB,GAAI1uB,EAAQm8C,SAER,IAAKn2C,EAAIoW,EAAM3c,OAAS,EAAI,EAAI,EAAGuG,EAAIoW,EAAM3c,OAAQuG,IAEjD,IADAyqB,EAAOrU,EAAMpW,GACRmxB,EAAI,EAAGA,EAAI1G,EAAKhB,KAAKhwB,OAAQ03B,IAAK,CACnC,GAAIqJ,GAAO/P,EAAKhB,KAAK0H,EACrBt5B,GAAE0hD,OAAO9uB,EAAK7E,SAASpC,EAAGiH,EAAK7E,SAASnC,GACxC5rB,EAAE4hD,OAAOhvB,EAAK7E,SAASpC,EAAa,GAATgX,EAAKhX,EAAQiH,EAAK7E,SAASnC,EAAa,GAAT+W,EAAK/W,OAIvE,KAAKzjB,EAAIoW,EAAM3c,OAAS,EAAI,EAAI,EAAGuG,EAAIoW,EAAM3c,OAAQuG,IAEjD,IADAyqB,EAAOrU,EAAMpW,GACRmxB,EAAI,EAAGA,EAAI1G,EAAKhB,KAAKhwB,OAAQ03B,IAE9Bt5B,EAAE0hD,OAAO9uB,EAAK7E,SAASpC,EAAGiH,EAAK7E,SAASnC,GACxC5rB,EAAE4hD,QAAQhvB,EAAKtD,SAAS,GAAG3D,EAAIiH,EAAKtD,SAASsD,EAAKtD,SAAS1tB,OAAO,GAAG+pB,GAAK,GAChEiH,EAAKtD,SAAS,GAAG1D,EAAIgH,EAAKtD,SAASsD,EAAKtD,SAAS1tB,OAAO,GAAGgqB,GAAK,GAMtFzpB,EAAQorB,YACRvtB,EAAE8sB,YAAc,YAChB9sB,EAAEixB,UAAY,IAEdjxB,EAAE8sB,YAAc,2BAChB9sB,EAAEogD,yBAA2B,UAC7BpgD,EAAEixB,UAAY,GAGlBjxB,EAAE+pB,SACF/pB,EAAEogD,yBAA2B,eAWjC9yB,EAAOozB,cAAgB,SAAS12C,EAAQ8hB,EAAQvlB,GAC5C,GAGI0Z,GACA2S,EACAhzB,EACA05B,EANAt5B,EAAIuG,EAEJpE,GADS6H,EAAOojB,OACNpjB,EAAO7H,QASrB,KAHAnC,EAAEuhD,YAGG3hD,EAAI,EAAGA,EAAIksB,EAAOlqB,OAAQhC,IAG3B,GAFAqgB,EAAO6L,EAAOlsB,GAETqgB,EAAKjW,OAAO6mB,QAIjB,IAAKyI,EAAI,EAAGA,EAAIrZ,EAAK1B,MAAM3c,OAAQ03B,IAC/B1G,EAAO3S,EAAK1B,MAAM+a,GAClBt5B,EAAEwhD,IAAI5uB,EAAK7E,SAASpC,EAAGiH,EAAK7E,SAASnC,EAAG,EAAG,EAAG,EAAIlV,KAAKmW,IAAI,GAC3D7sB,EAAEyhD,WAcV,KAVIt/C,EAAQorB,WACRvtB,EAAEouB,UAAY,YAEdpuB,EAAEouB,UAAY,kBAElBpuB,EAAEgqB,OAEFhqB,EAAEuhD,YAGG3hD,EAAI,EAAGA,EAAIksB,EAAOlqB,OAAQhC,IAC3BqgB,EAAO6L,EAAOlsB,GACVqgB,EAAKjW,OAAO6mB,UACZ7wB,EAAEwhD,IAAIvhC,EAAKuR,aAAa7F,EAAG1L,EAAKuR,aAAa5F,EAAG,EAAG,EAAG,EAAIlV,KAAKmW,IAAI,GACnE7sB,EAAEyhD,YAIVzhD,GAAEouB,UAAY,sBACdpuB,EAAEgqB,QAWNsD,EAAOqzB,aAAe,SAAS32C,EAAQ8hB,EAAQvlB,GAC3C,GAAIvG,GAAIuG,CAERvG,GAAEuhD,WAEF,KAAK,GAAI3hD,GAAI,EAAGA,EAAIksB,EAAOlqB,OAAQhC,IAAK,CACpC,GAAIqgB,GAAO6L,EAAOlsB,EAEbqgB,GAAKjW,OAAO6mB,UAGjB7wB,EAAE0hD,OAAOzhC,EAAK8N,SAASpC,EAAG1L,EAAK8N,SAASnC,GACxC5rB,EAAE4hD,OAAO3hC,EAAK8N,SAASpC,EAA8C,GAAzC1L,EAAK8N,SAASpC,EAAI1L,EAAKuR,aAAa7F,GAAQ1L,EAAK8N,SAASnC,EAA8C,GAAzC3L,EAAK8N,SAASnC,EAAI3L,EAAKuR,aAAa5F,KAGnI5rB,EAAEixB,UAAY,EACdjxB,EAAE8sB,YAAc,iBAChB9sB,EAAE+pB,UAWNuD,EAAOszB,QAAU,SAAS52C,EAAQ8hB,EAAQvlB,GACtC,GACI3G,GACAuI,EAFAnI,EAAIuG,CAIR,KAAK3G,EAAI,EAAGA,EAAIksB,EAAOlqB,OAAQhC,IAC3B,GAAKksB,EAAOlsB,GAAGoK,OAAO6mB,QAAtB,CAGA,GAAItS,GAAQuN,EAAOlsB,GAAG2e,KACtB,KAAKpW,EAAIoW,EAAM3c,OAAS,EAAI,EAAI,EAAGuG,EAAIoW,EAAM3c,OAAQuG,IAAK,CACtD,GAAIyqB,GAAOrU,EAAMpW,EACjBnI,GAAEqhD,KAAO,aACTrhD,EAAEouB,UAAY,wBACdpuB,EAAEshD,SAAS1uB,EAAKxe,GAAIwe,EAAK7E,SAASpC,EAAI,GAAIiH,EAAK7E,SAASnC,EAAI,OAaxE0B,EAAOsL,WAAa,SAAS5uB,EAAQ+uB,EAAOxyB,GACxC,GAEImzB,GACAE,EAIAh6B,EACAuI,EARAnI,EAAIuG,EACJpE,EAAU6H,EAAO7H,OAYrB,KAHAnC,EAAEuhD,YAGG3hD,EAAI,EAAGA,EAAIm5B,EAAMn3B,OAAQhC,IAG1B,GAFA85B,EAAOX,EAAMn5B,GAER85B,EAAKC,SAIV,IADAC,EAAYF,EAAKE,UACZzxB,EAAI,EAAGA,EAAIuxB,EAAKmD,eAAej7B,OAAQuG,IAAK,CAC7C,GAAIi1B,GAAU1D,EAAKmD,eAAe10B,GAC9BkwB,EAAS+E,EAAQ/E,MACrBr4B,GAAE6c,KAAKwb,EAAO1M,EAAI,IAAK0M,EAAOzM,EAAI,IAAK,IAAK,KAcpD,IAVIzpB,EAAQorB,WACRvtB,EAAEouB,UAAY,wBAEdpuB,EAAEouB,UAAY,SAElBpuB,EAAEgqB,OAEFhqB,EAAEuhD,YAGG3hD,EAAI,EAAGA,EAAIm5B,EAAMn3B,OAAQhC,IAG1B,GAFA85B,EAAOX,EAAMn5B,GAER85B,EAAKC,WAGVC,EAAYF,EAAKE,UAEbF,EAAKmD,eAAej7B,OAAS,GAAG,CAChC,GAAI2gD,GAAa7oB,EAAKmD,eAAe,GAAGxE,OAAO1M,EAC3C62B,EAAa9oB,EAAKmD,eAAe,GAAGxE,OAAOzM,CAEZ,KAA/B8N,EAAKmD,eAAej7B,SACpB2gD,GAAc7oB,EAAKmD,eAAe,GAAGxE,OAAO1M,EAAI+N,EAAKmD,eAAe,GAAGxE,OAAO1M,GAAK,EACnF62B,GAAc9oB,EAAKmD,eAAe,GAAGxE,OAAOzM,EAAI8N,EAAKmD,eAAe,GAAGxE,OAAOzM,GAAK,GAGnFgO,EAAUV,QAAUU,EAAUqD,SAAS,GAAGhd,OAAqC,IAA7B2Z,EAAUX,MAAM9K,SAClEnuB,EAAE0hD,OAAOa,EAAkC,EAArB3oB,EAAU8F,OAAO/T,EAAO62B,EAAkC,EAArB5oB,EAAU8F,OAAO9T,GAE5E5rB,EAAE0hD,OAAOa,EAAkC,EAArB3oB,EAAU8F,OAAO/T,EAAO62B,EAAkC,EAArB5oB,EAAU8F,OAAO9T,GAGhF5rB,EAAE4hD,OAAOW,EAAYC,GAIzBrgD,EAAQorB,WACRvtB,EAAE8sB,YAAc,sBAEhB9sB,EAAE8sB,YAAc,SAGpB9sB,EAAEixB,UAAY,EACdjxB,EAAE+pB,UAWNuD,EAAOuzB,YAAc,SAAS72C,EAAQ+uB,EAAOxyB,GACzC,GAEImzB,GACAE,EAEAX,EACAC,EACAt5B,EAPAI,EAAIuG,EACJpE,EAAU6H,EAAO7H,OAYrB,KAHAnC,EAAEuhD,YAGG3hD,EAAI,EAAGA,EAAIm5B,EAAMn3B,OAAQhC,IAG1B,GAFA85B,EAAOX,EAAMn5B,GAER85B,EAAKC,SAAV,CAGAC,EAAYF,EAAKE,UACjBX,EAAQW,EAAUX,MAClBC,EAAQU,EAAUV,KAElB,IAAII,GAAI,CAEHJ,GAAM/K,UAAa8K,EAAM9K,WAAUmL,EAAI,IACxCJ,EAAM/K,WAAUmL,EAAI,GAExBt5B,EAAE0hD,OAAOxoB,EAAMnL,SAASpC,EAAGuN,EAAMnL,SAASnC,GAC1C5rB,EAAE4hD,OAAO1oB,EAAMnL,SAASpC,EAAIiO,EAAUqG,YAAYtU,EAAI2N,EAAGJ,EAAMnL,SAASnC,EAAIgO,EAAUqG,YAAYrU,EAAI0N,GAEtGA,EAAI,EAECJ,EAAM/K,UAAa8K,EAAM9K,WAAUmL,EAAI,IACxCL,EAAM9K,WAAUmL,EAAI,GAExBt5B,EAAE0hD,OAAOzoB,EAAMlL,SAASpC,EAAGsN,EAAMlL,SAASnC,GAC1C5rB,EAAE4hD,OAAO3oB,EAAMlL,SAASpC,EAAIiO,EAAUqG,YAAYtU,EAAI2N,EAAGL,EAAMlL,SAASnC,EAAIgO,EAAUqG,YAAYrU,EAAI0N,GAGtGn3B,EAAQorB,WACRvtB,EAAE8sB,YAAc,sBAEhB9sB,EAAE8sB,YAAc,SAEpB9sB,EAAE+pB,UAWNuD,EAAOqN,KAAO,SAAS3wB,EAAQ2wB,EAAMp0B,GACjC,GAAIvG,GAAIuG,CACMyD,GAAO7H,QAETorB,WACRvtB,EAAE8sB,YAAc,sBAEhB9sB,EAAE8sB,YAAc,sBAGpB9sB,EAAEuhD,WAIF,KAAK,GAFDkB,GAAat1B,EAAOmP,KAAK3B,EAAKJ,SAEzB36B,EAAI,EAAGA,EAAI6iD,EAAW7gD,OAAQhC,IAAK,CACxC,GAAIm7B,GAAW0nB,EAAW7iD,EAE1B,MAAI+6B,EAAKJ,QAAQQ,GAAUn5B,OAAS,GAApC,CAGA,GAAIu5B,GAASJ,EAASzc,MAAM,MAC5Bte,GAAE6c,KAAK,GAAMqrB,SAAS/M,EAAO,GAAI,IAAMR,EAAKF,YACpC,GAAMyN,SAAS/M,EAAO,GAAI,IAAMR,EAAKD,aACrCC,EAAKF,YACLE,EAAKD,eAGjB16B,EAAEixB,UAAY,EACdjxB,EAAE+pB,UAUNuD,EAAOo1B,UAAY,SAASA,EAAWn8C,GACnC,GAIIgrB,GAHAoxB,GADSD,EAAUt1B,OACRs1B,EAAUC,UACrB34C,EAAS04C,EAAU14C,OACnB7H,EAAU6H,EAAO7H,OAGrB,IAAIA,EAAQ27C,UAAW,CACnB,GAAI8B,GAAc51C,EAAOunB,OAAOhV,IAAIoP,EAAI3hB,EAAOunB,OAAO7oB,IAAIijB,EACtDk0B,EAAe71C,EAAOunB,OAAOhV,IAAIqP,EAAI5hB,EAAOunB,OAAO7oB,IAAIkjB,EACvDk0B,EAAeF,EAAc51C,EAAO7H,QAAQoY,MAC5CwlC,EAAeF,EAAe71C,EAAO7H,QAAQqY,MAEjDjU,GAAQsnB,MAAM,EAAIiyB,EAAc,EAAIC,GACpCx5C,EAAQ6sB,WAAWppB,EAAOunB,OAAO7oB,IAAIijB,GAAI3hB,EAAOunB,OAAO7oB,IAAIkjB,GAG/D,IAAK,GAAIhsB,GAAI,EAAGA,EAAI+iD,EAAS/gD,OAAQhC,IAAK,CACtC,GAAImV,GAAO4tC,EAAS/iD,GAAGiX,IAOvB,QALAtQ,EAAQ6sB,UAAU,GAAK,IACvB7sB,EAAQ0qB,UAAY,EACpB1qB,EAAQumB,YAAc,sBACtBvmB,EAAQq8C,aAAa,EAAE,IAEf7tC,EAAKhP,MAEb,IAAK,OAGDwrB,EAASxc,EAAKwc,OACdhrB,EAAQg7C,YACRh7C,EAAQsW,KAAKnG,KAAK0lB,MAAM7K,EAAO7oB,IAAIijB,EAAI,GAAIjV,KAAK0lB,MAAM7K,EAAO7oB,IAAIkjB,EAAI,GACxDlV,KAAK0lB,MAAM7K,EAAOhV,IAAIoP,EAAI4F,EAAO7oB,IAAIijB,EAAI,GAAIjV,KAAK0lB,MAAM7K,EAAOhV,IAAIqP,EAAI2F,EAAO7oB,IAAIkjB,EAAI,IACnGrlB,EAAQk7C,YACRl7C,EAAQwjB,QAER,MAEJ,KAAK,aAGD,GAAImK,GAAQnf,EAAKkvB,MACblvB,GAAKkkB,QACL/E,EAAQnf,EAAKmvB,QACjB39B,EAAQg7C,YACRh7C,EAAQi7C,IAAIttB,EAAMvI,EAAGuI,EAAMtI,EAAG,GAAI,EAAG,EAAIlV,KAAKmW,IAC9CtmB,EAAQk7C,YACRl7C,EAAQwjB,SAMZxjB,EAAQq8C,gBACRr8C,EAAQ6sB,WAAW,IAAM,IAIC,OAA1BsvB,EAAUG,cACVt8C,EAAQ6sB,UAAU,GAAK,IACvB7sB,EAAQ0qB,UAAY,EACpB1qB,EAAQumB,YAAc,sBACtBvmB,EAAQ6nB,UAAY,sBACpBmD,EAASmxB,EAAUI,aACnBv8C,EAAQg7C,YACRh7C,EAAQsW,KAAKnG,KAAK0lB,MAAM7K,EAAO7oB,IAAIijB,GAAIjV,KAAK0lB,MAAM7K,EAAO7oB,IAAIkjB,GAChDlV,KAAK0lB,MAAM7K,EAAOhV,IAAIoP,EAAI4F,EAAO7oB,IAAIijB,GAAIjV,KAAK0lB,MAAM7K,EAAOhV,IAAIqP,EAAI2F,EAAO7oB,IAAIkjB,IAC3FrlB,EAAQk7C,YACRl7C,EAAQwjB,SACRxjB,EAAQyjB,OACRzjB,EAAQ6sB,WAAW,IAAM,KAGzBjxB,EAAQ27C,WACRv3C,EAAQ05C,aAAa,EAAG,EAAG,EAAG,EAAG,EAAG,GAW5C,IAAIlB,GAAgB,SAASxkC,EAAOC,GAChC,GAAIqrB,GAAS9hC,SAASE,cAAc,SAKpC,OAJA4hC,GAAOtrB,MAAQA,EACfsrB,EAAOrrB,OAASA,EAChBqrB,EAAOkd,cAAgB,WAAa,OAAO,GAC3Cld,EAAOmd,cAAgB,WAAa,OAAO,GACpCnd,GAUPuZ,EAAiB,SAASvZ,GAC1B,GAAIt/B,GAAUs/B,EAAOmZ,WAAW,KAMhC,QALuBhxC,OAAOi1C,kBAAoB,IACrB18C,EAAQ28C,8BAAgC38C,EAAQ48C,2BAC5C58C,EAAQ68C,0BAA4B78C,EAAQ88C,yBAC5C98C,EAAQ+8C,wBAA0B,IAanEjB,EAAc,SAASr4C,EAAQu5C,GAC/B,GAAIC,GAAQx5C,EAAOi1C,SAASsE,EAE5B,OAAIC,KAGJA,EAAQx5C,EAAOi1C,SAASsE,GAAa,GAAIE,OACzCD,EAAME,IAAMH,EAELC,IAUPrD,EAAmB,SAASn2C,EAAQwjB,GACpC,GAAIm2B,GAAgBn2B,CAEhB,kBAAiB5oB,KAAK4oB,KACtBm2B,EAAgB,OAASn2B,EAAa,KAE1CxjB,EAAO67B,OAAOrhC,MAAMgpB,WAAam2B,EACjC35C,EAAO67B,OAAOrhC,MAAMo/C,eAAiB,UACrC55C,EAAOk2C,kBAAoB1yB,QA0HhC+Y,oBAAoB,EAAEkE,oBAAoB,EAAElV,iBAAiB,GAAGuC,iBAAiB,GAAG2O,gBAAgB,GAAG/Q,qBAAqB,GAAGC,qBAAqB,KAAKkuB,IAAI,SAASp1B,EAAQ9uB,EAAOD,GAUxL,GAAIo9C,KAEJn9C,GAAOD,QAAUo9C,CAEjB,IAAIjuB,GAASJ,EAAQ,sBACjBT,EAAYS,EAAQ,qBACpBtB,EAASsB,EAAQ,kBACjBsH,EAAStH,EAAQ,kBACjBE,EAASF,EAAQ,uBAErB,WAEI,GAAIihB,GACAC,CAEkB,oBAAX3hC,UACP0hC,EAAyB1hC,OAAO4hC,uBAAyB5hC,OAAO6hC,6BAC/B7hC,OAAO8hC,0BAA4B9hC,OAAO+hC,yBAC1C,SAAStiC,GAAWO,OAAOT,WAAW,WAAaE,EAAS0f,EAAOvR,QAAW,IAAO,KAEtH+zB,EAAwB3hC,OAAOgiC,sBAAwBhiC,OAAOiiC,yBAC7BjiC,OAAOkiC,4BAA8BliC,OAAOmiC,wBAUjF2M,EAAWvtC,OAAS,SAASpN,GACzBgrB,EAAOjZ,KAAK,gEAEZ,IAAIib,IACAkL,WAAYyiB,EACZ1vB,OAAQ,KACR9P,QAAS,KACTqzB,eAAgB,KAChB9K,OAAQ,KACRie,SAAU,KACV78B,UAAW,KACX88B,gBAAiB,KACjBC,YAAa,KACb7hD,SACIoY,MAAO,IACPC,OAAQ,IACRgT,WAAY,UACZqwB,oBAAqB,OACrBC,WAAW,EACXjN,SAAS,EACTtjB,YAAY,EACZwwB,cAAc,EACdC,WAAW,EACXC,gBAAgB,EAChBC,YAAY,EACZC,cAAc,EACdC,gBAAgB,EAChBE,UAAU,EACVC,eAAe,EACfC,oBAAoB,EACpBC,SAAS,EACTC,aAAa,IAIjB10C,EAASmjB,EAAO9qB,OAAO8sB,EAAUhtB,GACjC8hD,GAAej6C,EAAO7H,QAAQorB,YAA4C,gBAA9BvjB,EAAO7H,QAAQqrB,UAmD/D,OAhDAxjB,GAAOg6C,YAAch6C,EAAOg6C,cACxBE,KAAMl6C,EAAO67B,OACboe,YAAaA,EACbE,WAAW,EACXC,gBAAiBjiD,EAAQqrB,YAG7BxjB,EAAO47B,MAAQzjC,EAAQyjC,MACvB57B,EAAOojB,OAASjrB,EAAQirB,OACxBpjB,EAAO85C,SAAW95C,EAAO85C,UAAY,GAAIO,MAAKC,cAAct6C,EAAO7H,QAAQoY,MAAOvQ,EAAO7H,QAAQqY,OAAQxQ,EAAOg6C,aAChHh6C,EAAOid,UAAYjd,EAAOid,WAAa,GAAIo9B,MAAKE,UAChDv6C,EAAO+5C,gBAAkB/5C,EAAO+5C,iBAAmB,GAAIM,MAAKE,UAC5Dv6C,EAAO67B,OAAS77B,EAAO67B,QAAU77B,EAAO85C,SAASI,KACjDl6C,EAAOunB,OAASvnB,EAAOunB,SACnB7oB,KACIijB,EAAG,EACHC,EAAG,GAEPrP,KACIoP,EAAG3hB,EAAO7H,QAAQoY,MAClBqR,EAAG5hB,EAAO7H,QAAQqY,SAK1Bub,EAAOjd,GAAG9O,EAAOojB,OAAQ,eAAgB,WACrC0vB,EAAWzlB,MAAMrtB,KAIrBA,EAAOi1C,YACPj1C,EAAOw6C,WACPx6C,EAAOy6C,cAGPz6C,EAAOid,UAAUy9B,SAAS16C,EAAO+5C,iBAG7B52B,EAAOqa,UAAUx9B,EAAOsT,SACxBtT,EAAOsT,QAAQtW,YAAYgD,EAAO67B,QAElC1Y,EAAOjZ,KAAK,+EAIhBlK,EAAO67B,OAAOkd,cAAgB,WAAa,OAAO,GAClD/4C,EAAO67B,OAAOmd,cAAgB,WAAa,OAAO,GAE3Ch5C,GASX8yC,EAAWjnC,IAAM,SAAS7L,IACtB,QAAUm1C,GAAKplC,GACX/P,EAAO2mC,eAAiBjB,EAAuByP,GAC/CrC,EAAWnvB,MAAM3jB,OAUzB8yC,EAAW7L,KAAO,SAASjnC,GACvB2lC,EAAsB3lC,EAAO2mC,iBASjCmM,EAAWzlB,MAAQ,SAASrtB,GAKxB,IAJA,GAAIid,GAAYjd,EAAOid,UACnB88B,EAAkB/5C,EAAO+5C,gBAGtB98B,EAAUxlB,SAAS,IACtBwlB,EAAU7iB,YAAY6iB,EAAUxlB,SAAS,GAI7C,MAAOsiD,EAAgBtiD,SAAS,IAC5BsiD,EAAgB3/C,YAAY2/C,EAAgBtiD,SAAS,GAGzD,IAAIkjD,GAAW36C,EAAOw6C,QAAQ,OAG9Bx6C,GAAOi1C,YACPj1C,EAAOw6C,WACPx6C,EAAOy6C,cAGPz6C,EAAOw6C,QAAQ,QAAUG,EACrBA,GACA19B,EAAU29B,WAAWD,EAAU,GAGnC36C,EAAOid,UAAUy9B,SAAS16C,EAAO+5C,iBAGjC/5C,EAAOk2C,kBAAoB,KAG3Bj5B,EAAU4G,MAAMyD,IAAI,EAAG,GACvBrK,EAAU8G,SAASuD,IAAI,EAAG,IAU9BwrB,EAAW+H,cAAgB,SAAS76C,EAAQwjB,GACxC,GAAIxjB,EAAOk2C,oBAAsB1yB,EAAY,CACzC,GAAIs3B,GAAUt3B,EAAW1W,UAAwC,IAA7B0W,EAAW1W,QAAQ,KACnD6tC,EAAW36C,EAAOw6C,QAAQ,OAE9B,IAAIM,EAAS,CAET,GAAIC,GAAQ53B,EAAO4a,cAAcva,EACjCxjB,GAAO85C,SAASM,gBAAkBW,EAG9BJ,GACA36C,EAAOid,UAAU7iB,YAAYugD,OAGjC,KAAKA,EAAU,CACX,GAAI53B,GAAUs1B,EAAYr4C,EAAQwjB,EAElCm3B,GAAW36C,EAAOw6C,QAAQ,QAAU,GAAIH,MAAKW,OAAOj4B,GACpD43B,EAAS52B,SAASpC,EAAI,EACtBg5B,EAAS52B,SAASnC,EAAI,EACtB5hB,EAAOid,UAAU29B,WAAWD,EAAU,GAI9C36C,EAAOk2C,kBAAoB1yB,IAUnCsvB,EAAWnvB,MAAQ,SAAS3jB,GACxB,GAQIpK,GARAwtB,EAASpjB,EAAOojB,OAChBO,EAAQP,EAAOO,MACfm2B,EAAW95C,EAAO85C,SAClB78B,EAAYjd,EAAOid,UACnB9kB,EAAU6H,EAAO7H,QACjB2pB,EAASkC,EAAUuJ,UAAU5J,GAC7B6J,EAAiBxJ,EAAUwJ,eAAe7J,GAC1CsI,IAGA9zB,GAAQorB,WACRuvB,EAAW+H,cAAc76C,EAAQ7H,EAAQ07C,qBAEzCf,EAAW+H,cAAc76C,EAAQ7H,EAAQqrB,WAI7C,IAAIoyB,GAAc51C,EAAOunB,OAAOhV,IAAIoP,EAAI3hB,EAAOunB,OAAO7oB,IAAIijB,EACtDk0B,EAAe71C,EAAOunB,OAAOhV,IAAIqP,EAAI5hB,EAAOunB,OAAO7oB,IAAIkjB,EACvDk0B,EAAeF,EAAc51C,EAAO7H,QAAQoY,MAC5CwlC,EAAeF,EAAe71C,EAAO7H,QAAQqY,MAEjD,IAAIrY,EAAQ27C,UAAW,CAEnB,IAAKl+C,EAAI,EAAGA,EAAIksB,EAAOlqB,OAAQhC,IAAK,CAChC,GAAIqgB,GAAO6L,EAAOlsB,EAClBqgB,GAAKjW,OAAO+hB,OAAO8E,QAAUhC,EAAOuK,SAASnZ,EAAKsR,OAAQvnB,EAAOunB,QAIrE,IAAK3xB,EAAI,EAAGA,EAAI43B,EAAe51B,OAAQhC,IAAK,CACxC,GAAI+2B,GAAaa,EAAe53B,GAC5Bq5B,EAAQtC,EAAWsC,MACnBC,EAAQvC,EAAWuC,MACnB8L,EAAcrO,EAAWsN,OACzBgB,EAActO,EAAWuN,MAEzBjL,KAAO+L,EAAcrW,EAAOpC,IAAI0M,EAAMlL,SAAU4I,EAAWsN,SAC3D/K,IAAO+L,EAActW,EAAOpC,IAAI2M,EAAMnL,SAAU4I,EAAWuN,SAE1Dc,GAAgBC,KAGjBpW,EAAOiQ,SAAS90B,EAAOunB,OAAQyT,IAAgBnW,EAAOiQ,SAAS90B,EAAOunB,OAAQ0T,KAC9EhP,EAAYn0B,KAAK60B,IAIzB1P,EAAU4G,MAAMyD,IAAI,EAAIwuB,EAAc,EAAIC,GAC1C94B,EAAU8G,SAASuD,KAAKtnB,EAAOunB,OAAO7oB,IAAIijB,GAAK,EAAIm0B,IAAgB91C,EAAOunB,OAAO7oB,IAAIkjB,GAAK,EAAIm0B,QAE9F9pB,GAAcuB,CAGlB,KAAK53B,EAAI,EAAGA,EAAIksB,EAAOlqB,OAAQhC,IAC3Bk9C,EAAW78B,KAAKjW,EAAQ8hB,EAAOlsB,GAEnC,KAAKA,EAAI,EAAGA,EAAIq2B,EAAYr0B,OAAQhC,IAChCk9C,EAAWnmB,WAAW3sB,EAAQisB,EAAYr2B,GAE9CkkD,GAAS95C,OAAOid,IAWpB61B,EAAWnmB,WAAa,SAAS3sB,EAAQ2sB,GACrC,GACIsC,IADSjvB,EAAOojB,OACRuJ,EAAWsC,OACnBC,EAAQvC,EAAWuC,MACnB+K,EAAStN,EAAWsN,OACpBC,EAASvN,EAAWuN,OACpBjd,EAAYjd,EAAOid,UACnBg+B,EAAmBtuB,EAAW3sB,OAC9Bk7C,EAAc,KAAOvuB,EAAWviB,GAChC+wC,EAAYn7C,EAAOy6C,WAAWS,EAOlC,IAJKC,IACDA,EAAYn7C,EAAOy6C,WAAWS,GAAe,GAAIb,MAAKe,WAGrDH,EAAiBp0B,UAAY8F,EAAWsN,SAAWtN,EAAWuN,OAE/D,WADAihB,GAAU9tB,SAKyC,IAAnDlK,EAAOrW,QAAQmQ,EAAUxlB,SAAU0jD,IACnCl+B,EAAUy9B,SAASS,GAGvBA,EAAU9tB,QACV8tB,EAAUE,UAAU,EAAG,GACvBF,EAAUG,UAAUL,EAAiBh0B,UAAW9D,EAAO4a,cAAckd,EAAiBn4B,aAAc,GAEhGmM,EACAksB,EAAUzD,OAAOzoB,EAAMlL,SAASpC,EAAIsY,EAAOtY,EAAGsN,EAAMlL,SAASnC,EAAIqY,EAAOrY,GAExEu5B,EAAUzD,OAAOzd,EAAOtY,EAAGsY,EAAOrY,GAGlCsN,EACAisB,EAAUvD,OAAO1oB,EAAMnL,SAASpC,EAAIuY,EAAOvY,EAAGuN,EAAMnL,SAASnC,EAAIsY,EAAOtY,GAExEu5B,EAAUvD,OAAO1d,EAAOvY,EAAGuY,EAAOtY,GAGtCu5B,EAAUI,WAUdzI,EAAW78B,KAAO,SAASjW,EAAQiW,GAC/B,GACIulC,IADSx7C,EAAOojB,OACHnN,EAAKjW,OAEtB,IAAKw7C,EAAW30B,QAGhB,GAAI20B,EAAWz5B,QAAUy5B,EAAWz5B,OAAOgB,QAAS,CAChD,GAAI04B,GAAW,KAAOxlC,EAAK7L,GACvB2X,EAAS/hB,EAAOw6C,QAAQiB,GACxB1B,EAAkB/5C,EAAO+5C,eAGxBh4B,KACDA,EAAS/hB,EAAOw6C,QAAQiB,GAAYC,EAAkB17C,EAAQiW,KAGR,IAAtDkN,EAAOrW,QAAQitC,EAAgBtiD,SAAUsqB,IACzCg4B,EAAgBW,SAAS34B,GAG7BA,EAAOgC,SAASpC,EAAI1L,EAAK8N,SAASpC,EAClCI,EAAOgC,SAASnC,EAAI3L,EAAK8N,SAASnC,EAClCG,EAAOkI,SAAWhU,EAAK2M,MACvBb,EAAO8B,MAAMlC,EAAI65B,EAAWz5B,OAAOkB,QAAU,EAC7ClB,EAAO8B,MAAMjC,EAAI45B,EAAWz5B,OAAOmB,QAAU,MAC1C,CACH,GAAIg4B,GAAc,KAAOjlC,EAAK7L,GAC1B+wC,EAAYn7C,EAAOy6C,WAAWS,GAC9Bj+B,EAAYjd,EAAOid,SAGlBk+B,KACDA,EAAYn7C,EAAOy6C,WAAWS,GAAeS,EAAqB37C,EAAQiW,GAC1EklC,EAAUS,aAAe3lC,EAAK2M,QAIqB,IAAnDO,EAAOrW,QAAQmQ,EAAUxlB,SAAU0jD,IACnCl+B,EAAUy9B,SAASS,GAGvBA,EAAUp3B,SAASpC,EAAI1L,EAAK8N,SAASpC,EACrCw5B,EAAUp3B,SAASnC,EAAI3L,EAAK8N,SAASnC,EACrCu5B,EAAUlxB,SAAWhU,EAAK2M,MAAQu4B,EAAUS,cAapD,IAAIF,GAAoB,SAAS17C,EAAQiW,GACrC,GAAIulC,GAAavlC,EAAKjW,OAClB67C,EAAcL,EAAWz5B,OAAOgB,QAChCA,EAAUs1B,EAAYr4C,EAAQ67C,GAC9B95B,EAAS,GAAIs4B,MAAKW,OAAOj4B,EAK7B,OAHAhB,GAAO+5B,OAAOn6B,EAAI1L,EAAKjW,OAAO+hB,OAAOgF,QACrChF,EAAO+5B,OAAOl6B,EAAI3L,EAAKjW,OAAO+hB,OAAOiF,QAE9BjF,GAYP45B,EAAuB,SAAS37C,EAAQiW,GACxC,GAQI2S,GARA4yB,EAAavlC,EAAKjW,OAClB7H,EAAU6H,EAAO7H,QACjBgjD,EAAY,GAAId,MAAKe,SACrBh3B,EAAYjB,EAAO4a,cAAcyd,EAAWp3B,WAC5CtB,EAAcK,EAAO4a,cAAcyd,EAAW14B,aAC9Ci5B,EAAuB54B,EAAO4a,cAAcyd,EAAW14B,aACvDk5B,EAAuB74B,EAAO4a,cAAc,QAC5Cke,EAAgC94B,EAAO4a,cAAc,UAGzDod,GAAU9tB,OAGV,KAAK,GAAIiC,GAAIrZ,EAAK1B,MAAM3c,OAAS,EAAI,EAAI,EAAG03B,EAAIrZ,EAAK1B,MAAM3c,OAAQ03B,IAAK,CACpE1G,EAAO3S,EAAK1B,MAAM+a,GAEbn3B,EAAQorB,YAIT43B,EAAUE,UAAU,EAAG,GACvBF,EAAUG,UAAU,EAAGU,EAAsB,KAJ7Cb,EAAUE,UAAUj3B,EAAW,GAC/B+2B,EAAUG,UAAUE,EAAWv0B,UAAWnE,EAAa,IAM3Dq4B,EAAUzD,OAAO9uB,EAAKtD,SAAS,GAAG3D,EAAI1L,EAAK8N,SAASpC,EAAGiH,EAAKtD,SAAS,GAAG1D,EAAI3L,EAAK8N,SAASnC,EAE1F,KAAK,GAAIzjB,GAAI,EAAGA,EAAIyqB,EAAKtD,SAAS1tB,OAAQuG,IACtCg9C,EAAUvD,OAAOhvB,EAAKtD,SAASnnB,GAAGwjB,EAAI1L,EAAK8N,SAASpC,EAAGiH,EAAKtD,SAASnnB,GAAGyjB,EAAI3L,EAAK8N,SAASnC,EAG9Fu5B,GAAUvD,OAAOhvB,EAAKtD,SAAS,GAAG3D,EAAI1L,EAAK8N,SAASpC,EAAGiH,EAAKtD,SAAS,GAAG1D,EAAI3L,EAAK8N,SAASnC,GAE1Fu5B,EAAUI,WAGNpjD,EAAQq8C,oBAAsBr8C,EAAQm8C,YACtC6G,EAAUE,UAAU,EAAG,GAEnBljD,EAAQorB,WACR43B,EAAUG,UAAU,EAAGW,EAA+B,GAEtDd,EAAUG,UAAU,EAAGS,GAG3BZ,EAAUzD,OAAO9uB,EAAK7E,SAASpC,EAAI1L,EAAK8N,SAASpC,EAAGiH,EAAK7E,SAASnC,EAAI3L,EAAK8N,SAASnC,GACpFu5B,EAAUvD,QAAShvB,EAAKtD,SAAS,GAAG3D,EAAIiH,EAAKtD,SAASsD,EAAKtD,SAAS1tB,OAAO,GAAG+pB,GAAK,EAAI1L,EAAK8N,SAASpC,GAClFiH,EAAKtD,SAAS,GAAG1D,EAAIgH,EAAKtD,SAASsD,EAAKtD,SAAS1tB,OAAO,GAAGgqB,GAAK,EAAI3L,EAAK8N,SAASnC,GAErGu5B,EAAUI,WAIlB,MAAOJ,IAYP9C,EAAc,SAASr4C,EAAQu5C,GAC/B,GAAIx2B,GAAU/iB,EAAOi1C,SAASsE,EAK9B,OAHKx2B,KACDA,EAAU/iB,EAAOi1C,SAASsE,GAAac,KAAK6B,QAAQC,UAAU5C,IAE3Dx2B,QAKZwZ,oBAAoB,EAAEhR,iBAAiB,GAAGuC,iBAAiB,GAAGpC,qBAAqB,GAAGC,qBAAqB,UAAU,KAAK,Q5Bo2GhG71B,KAAKJ,EAASH,EAAoB,KAIzD,SAAUI,EAAQD,G6Br8axBC,EAAAD,SAAkB4rB,MAAA,8BAAAC,gBAAA,wCAAA66B,gBAAA,sCAAAC,sBAAA,4CAAAC,uBAAA,+C7B48aZ,SAAU3mD,EAAQD,EAASH,GAEjC,YAkBA,SAASsP,GAAgBC,EAAUC,GAAe,KAAMD,YAAoBC,IAAgB,KAAM,IAAIC,WAAU,qCAEhH,QAASC,GAA2BC,EAAMpP,GAAQ,IAAKoP,EAAQ,KAAM,IAAIC,gBAAe,4DAAgE,QAAOrP,GAAyB,gBAATA,IAAqC,kBAATA,GAA8BoP,EAAPpP,EAElO,QAASsP,GAAUC,EAAUC,GAAc,GAA0B,kBAAfA,IAA4C,OAAfA,EAAuB,KAAM,IAAIN,WAAU,iEAAoEM,GAAeD,GAASvO,UAAYT,OAAOkP,OAAOD,GAAcA,EAAWxO,WAAa6I,aAAepF,MAAO8K,EAAU7O,YAAY,EAAOgP,UAAU,EAAMjP,cAAc,KAAe+O,IAAYjP,OAAOoP,eAAiBpP,OAAOoP,eAAeJ,EAAUC,GAAcD,EAASK,UAAYJ,GAnBjejP,OAAOC,eAAeZ,EAAS,cAC7B6E,OAAO,IAET7E,EAAQ6oB,QAAMvmB,EAEd,IAAIuO,GAAe,WAAc,QAASU,GAAiBF,EAAQxO,GAAS,IAAK,GAAI3C,GAAI,EAAGA,EAAI2C,EAAMX,OAAQhC,IAAK,CAAE,GAAIsR,GAAa3O,EAAM3C,EAAIsR,GAAW1Q,WAAa0Q,EAAW1Q,aAAc,EAAO0Q,EAAW3Q,cAAe,EAAU,SAAW2Q,KAAYA,EAAW1B,UAAW,GAAMnP,OAAOC,eAAeyQ,EAAQG,EAAWhP,IAAKgP,IAAiB,MAAO,UAAUnC,EAAaoC,EAAYC,GAAiJ,MAA9HD,IAAYF,EAAiBlC,EAAYjO,UAAWqQ,GAAiBC,GAAaH,EAAiBlC,EAAaqC,GAAqBrC,M8Br9ahiByB,EAAAjR,EAAA,GACAumB,EAAAvmB,EAAA,I9B09aIgnD,EAEJ,SAAgCjkD,GAAO,MAAOA,IAAOA,EAAI3B,WAAa2B,GAAQsL,QAAStL,IAFpDwjB,EAUzBpmB,G8Bl+aG6oB,I9Bk+aW,SAAUlX,GAGhC,QAASkX,KAGP,MAFA1Z,GAAgB/I,KAAMyiB,GAEftZ,EAA2BnJ,MAAOyiB,EAAI7Y,WAAarP,OAAOgQ,eAAekY,IAAMjY,MAAMxK,KAAMnE,YAmBpG,MAxBAyN,GAAUmZ,EAAKlX,GAQfd,EAAagY,IACXrmB,IAAK,wBACLqC,MAAO,W8B3+aP,OAAO,K9B++aPrC,IAAK,SACLqC,MAAO,W8B7+aP,OACE,EAAAiM,EAAArP,GAAA,OAAKmnB,MAAOi+B,EAAA34C,QAAO44C,MACjB,EAAAh2C,EAAArP,GAAA,OAAKmnB,MAAOi+B,EAAA34C,QAAO64C,kB9Bo/alBl+B,GACP/X,EAAQvG,YAIJ,SAAUtK,EAAQD,G+BpgbxBC,EAAAD,SAAkB8mD,IAAA,4BAAAC,WAAA,mCAAAl8B,aAAA,mCAAA/Y,cAAA,oCAAAC,aAAA,mCAAAC,mBAAA,yCAAAg1C,uBAAA,6CAAAhvB,KAAA,6BAAAivB,aAAA,uC/B2gbZ,SAAUhnD,EAAQD,EAASH,GAEjC,YAkBA,SAASsP,GAAgBC,EAAUC,GAAe,KAAMD,YAAoBC,IAAgB,KAAM,IAAIC,WAAU,qCAEhH,QAASC,GAA2BC,EAAMpP,GAAQ,IAAKoP,EAAQ,KAAM,IAAIC,gBAAe,4DAAgE,QAAOrP,GAAyB,gBAATA,IAAqC,kBAATA,GAA8BoP,EAAPpP,EAElO,QAASsP,GAAUC,EAAUC,GAAc,GAA0B,kBAAfA,IAA4C,OAAfA,EAAuB,KAAM,IAAIN,WAAU,iEAAoEM,GAAeD,GAASvO,UAAYT,OAAOkP,OAAOD,GAAcA,EAAWxO,WAAa6I,aAAepF,MAAO8K,EAAU7O,YAAY,EAAOgP,UAAU,EAAMjP,cAAc,KAAe+O,IAAYjP,OAAOoP,eAAiBpP,OAAOoP,eAAeJ,EAAUC,GAAcD,EAASK,UAAYJ,GAnBjejP,OAAOC,eAAeZ,EAAS,cAC7B6E,OAAO,IAET7E,EAAQkpB,eAAa5mB,EAErB,IAAIuO,GAAe,WAAc,QAASU,GAAiBF,EAAQxO,GAAS,IAAK,GAAI3C,GAAI,EAAGA,EAAI2C,EAAMX,OAAQhC,IAAK,CAAE,GAAIsR,GAAa3O,EAAM3C,EAAIsR,GAAW1Q,WAAa0Q,EAAW1Q,aAAc,EAAO0Q,EAAW3Q,cAAe,EAAU,SAAW2Q,KAAYA,EAAW1B,UAAW,GAAMnP,OAAOC,eAAeyQ,EAAQG,EAAWhP,IAAKgP,IAAiB,MAAO,UAAUnC,EAAaoC,EAAYC,GAAiJ,MAA9HD,IAAYF,EAAiBlC,EAAYjO,UAAWqQ,GAAiBC,GAAaH,EAAiBlC,EAAaqC,GAAqBrC,MgCphbhiByB,EAAAjR,EAAA,GACAwmB,EAAAxmB,EAAA,IhCyhbIqnD,EAEJ,SAAgCtkD,GAAO,MAAOA,IAAOA,EAAI3B,WAAa2B,GAAQsL,QAAStL,IAF7CyjB,EAUzBrmB,GgCjibJkpB,WhCiibyB,SAAUvX,GAG9C,QAASuX,KAGP,MAFA/Z,GAAgB/I,KAAM8iB,GAEf3Z,EAA2BnJ,MAAO8iB,EAAWlZ,WAAarP,OAAOgQ,eAAeuY,IAAatY,MAAMxK,KAAMnE,YAelH,MApBAyN,GAAUwZ,EAAYvX,GAQtBd,EAAaqY,IACX1mB,IAAK,wBACLqC,MAAO,WgC1ibP,OAAO,KhC8ibPrC,IAAK,SACLqC,MAAO,WgC5ibP,OAAO,EAAAiM,EAAArP,GAAA,OAAKmnB,MAAOs+B,EAAAh5C,QAAO,qBhCijbrBgb,GACPpY,EAAQvG,YAIJ,SAAUtK,EAAQD,GiC/jbxBC,EAAAD,SAAkBmnD,cAAA,sCjCskbZ,SAAUlnD,EAAQD,EAASH,GAEjC,YAkBA,SAASsP,GAAgBC,EAAUC,GAAe,KAAMD,YAAoBC,IAAgB,KAAM,IAAIC,WAAU,qCAEhH,QAASC,GAA2BC,EAAMpP,GAAQ,IAAKoP,EAAQ,KAAM,IAAIC,gBAAe,4DAAgE,QAAOrP,GAAyB,gBAATA,IAAqC,kBAATA,GAA8BoP,EAAPpP,EAElO,QAASsP,GAAUC,EAAUC,GAAc,GAA0B,kBAAfA,IAA4C,OAAfA,EAAuB,KAAM,IAAIN,WAAU,iEAAoEM,GAAeD,GAASvO,UAAYT,OAAOkP,OAAOD,GAAcA,EAAWxO,WAAa6I,aAAepF,MAAO8K,EAAU7O,YAAY,EAAOgP,UAAU,EAAMjP,cAAc,KAAe+O,IAAYjP,OAAOoP,eAAiBpP,OAAOoP,eAAeJ,EAAUC,GAAcD,EAASK,UAAYJ,GAnBjejP,OAAOC,eAAeZ,EAAS,cAC7B6E,OAAO,IAET7E,EAAQipB,aAAW3mB,EAEnB,IAAIuO,GAAe,WAAc,QAASU,GAAiBF,EAAQxO,GAAS,IAAK,GAAI3C,GAAI,EAAGA,EAAI2C,EAAMX,OAAQhC,IAAK,CAAE,GAAIsR,GAAa3O,EAAM3C,EAAIsR,GAAW1Q,WAAa0Q,EAAW1Q,aAAc,EAAO0Q,EAAW3Q,cAAe,EAAU,SAAW2Q,KAAYA,EAAW1B,UAAW,GAAMnP,OAAOC,eAAeyQ,EAAQG,EAAWhP,IAAKgP,IAAiB,MAAO,UAAUnC,EAAaoC,EAAYC,GAAiJ,MAA9HD,IAAYF,EAAiBlC,EAAYjO,UAAWqQ,GAAiBC,GAAaH,EAAiBlC,EAAaqC,GAAqBrC,MkC/kbhiByB,EAAAjR,EAAA,GACAymB,EAAAzmB,EAAA,IlColbIunD,EAEJ,SAAgCxkD,GAAO,MAAOA,IAAOA,EAAI3B,WAAa2B,GAAQsL,QAAStL,IAF/C0jB,EAUzBtmB,GkC5lbFipB,SlC4lbqB,SAAUtX,GAG1C,QAASsX,KAGP,MAFA9Z,GAAgB/I,KAAM6iB,GAEf1Z,EAA2BnJ,MAAO6iB,EAASjZ,WAAarP,OAAOgQ,eAAesY,IAAWrY,MAAMxK,KAAMnE,YAe9G,MApBAyN,GAAUuZ,EAAUtX,GAQpBd,EAAaoY,IACXzmB,IAAK,wBACLqC,MAAO,WkCrmbP,OAAO,KlCymbPrC,IAAK,SACLqC,MAAO,WkCvmbP,OAAO,EAAAiM,EAAArP,GAAA,OAAKmnB,MAAOw+B,EAAAl5C,QAAO,mBlC4mbrB+a,GACPnY,EAAQvG,YAIJ,SAAUtK,EAAQD,GmC1nbxBC,EAAAD,SAAkBqnD,YAAA,oCnCiobZ,SAAUpnD,EAAQD,EAASH,GAEjC,YACA,IAAI4kB,GAAgCC,EAA8BC,EAE9D3f,EAA4B,kBAAXuI,SAAoD,gBAApBA,QAAOC,SAAwB,SAAU5K,GAAO,aAAcA,IAAS,SAAUA,GAAO,MAAOA,IAAyB,kBAAX2K,SAAyB3K,EAAIqH,cAAgBsD,QAAU3K,IAAQ2K,OAAOnM,UAAY,eAAkBwB,KoCvobrQ,SAASuD,EAAEnF,GAAG,UAAAgE,EAAiBhF,QAAS,KAAoBC,EAAOe,EAAEhB,IAA+C0kB,GAAQ1kB,GAARykB,EAAA,MAAAniB,MAAAqiB,EAAA,kBAAAF,KAAA7T,MAAA5Q,EAAA0kB,GAAAD,KAAAxkB,EAAAD,QAAA2kB,KAApHriB,EAA8K,SAAS6D,GAAgB,QAASnF,KAAI,MAAOsN,QAAOg5C,GAAG,GAAI56C,GAAE/L,OAAOyQ,QAAQ,SAASjL,GAAG,IAAI,GAAInF,GAAE,EAAEA,EAAEiB,UAAUC,OAAOlB,IAAI,CAAC,GAAI0L,GAAEzK,UAAUjB,EAAG,KAAI,GAAIN,KAAKgM,GAAE/L,OAAOS,UAAUC,eAAejB,KAAKsM,EAAEhM,KAAKyF,EAAEzF,GAAGgM,EAAEhM,IAAI,MAAOyF,GAAGA,GAAEgc,6BAA6B,SAAShc,GAAG,GAAIzF,MAAKkkB,EAAEze,EAAE3F,KAAK2H,EAAEhC,EAAE0b,aAAa3hB,EAAEiG,EAAEqJ,KAAKrP,EAAEgG,EAAEU,OAAQ,MAAK+d,GAAGzc,GAAGjI,GAAGC,GAAG,KAAM,IAAIiS,OAAM,0JAA2J,IAAI9R,GAAEiB,EAAEhB,EAAEquB,EAAElmB,EAAEyF,EAAE7M,EAAE4qB,EAAEq7B,GAAGjnD,EAAEJ,EAAEwU,GAAGnT,EAAEpB,EAAEuU,GAAGnU,EAAEL,EAAE4Y,MAAM8V,EAAE1uB,EAAEkiB,cAAc1Z,EAAEpI,IAAIiB,EAAE4M,EAAE9J,SAASmjD,UAAUC,WAAWnnD,EAAE,MAAMA,EAAE,KAAKonD,WAAWnnD,GAAG,KAAKonD,WAAW/4B,EAAErsB,OAAOqsB,EAAEg5B,eAAe,KAAKC,WAAWj5B,EAAErsB,OAAOqsB,EAAEk5B,WAAW,GAAG,KAAKC,WAAWn5B,EAAErsB,OAAOqsB,EAAEo5B,WAAW,KAAKC,WAAW95C,EAAE7I,QAAQ,sBAAsB,MAAM4iD,WAAW/5C,EAAE7I,QAAQ,iBAAiB,IAAIA,QAAQ,QAAQ,IAAI6iD,YAAYz/C,EAAE,KAAKnH,EAAE,MAAMA,EAAE,OAAOopB,GAAGrpB,EAAEZ,EAAEwrB,GAAE,EAAG,SAAS/lB,EAAEzF,EAAEkkB,EAAEzc,EAAEjI,GAAG,IAAI0kB,EAAE/B,WAAW+B,EAAEjC,OAAO,KAAM,IAAIvQ,OAAM,oGAAqGpR,MAAKkrB,IAAI,SAAS/lB,EAAEnF,GAAGsN,OAAOg5C,GAAG,UAAUc,WAAWpnD,EAAEqnD,aAAa,OAAO7nD,KAAK2F,IAAImI,OAAOg5C,GAAGnhD,EAAE,OAAO,eAAc,IAAKA,EAAEzF,GAAGwrB,GAAE,GAAI5d,OAAOg5C,GAAGnhD,EAAE,QAAQ,QAAQ,SAASA,EAAEnF,GAAG,GAAIN,KAAKyF,GAAE9E,eAAe,cAAcX,EAAE4nD,cAAcniD,EAAE0c,UAAU1c,EAAE9E,eAAe,YAAYX,EAAE6nD,YAAYpiD,EAAEwc,QAAQxc,EAAE9E,eAAe,WAAWX,EAAE8nD,WAAWriD,EAAE2c,OAAO3c,EAAE9E,eAAe,WAAWX,EAAE+nD,WAAWtiD,EAAEtB,OAAOnE,EAAEgoD,eAAeviD,EAAEuiD,iBAAgB,CAAG,IAAI9jC,GAAElY,KAAK1L,EAAEmF,EAAEwiD,aAAc,OAAOj8C,MAAKhM,EAAEkkB,IAAIA,EAAEzc,KAAK7G,EAAEc,KAAKwiB,KAAKvkB,EAAE0U,YAAY,WAAW,GAAG/T,IAAI,IAAIgU,cAAc3U,GAAGK,EAAEwB,QAAQ,CAAC,GAAIiE,GAAEzF,EAAEujB,OAAQ0G,GAAE/F,EAAEzc,EAAEhC,EAAEohD,KAAK,IAAK,QAAOxkC,UAAU,SAAS5c,GAAGwkB,EAAE/F,EAAEzc,EAAEhC,EAAEohD,MAAM5mD,OAAOC,eAAeuF,EAAE,cAActB,OAAM,OpCyrb35D,SAAU5E,EAAQD,EAASH,GAEjC,YqCvrbO,SAAS0iB,GAAcgC,GAC5B,MAAOqkC,GAA4BrkC,GAGrC,QAASqkC,GAA6BC,GACpC,GAAM9gC,GAAU8gC,EAAIlN,MAAMmN,EAC1B,OAAI/gC,IAAWA,EAAQ7lB,OACd6lB,EAAQ,GAEV,KrCirbTpnB,OAAOC,eAAeZ,EAAS,cAC7B6E,OAAO,IAET7E,EqC7rbgBuiB,cAFhB,IAAMumC,GAAoB","file":"v1-bundle-b13343bf5e67236e0fb7.js","sourcesContent":["/******/ (function(modules) { // webpackBootstrap\n/******/ \t// The module cache\n/******/ \tvar installedModules = {};\n/******/\n/******/ \t// The require function\n/******/ \tfunction __webpack_require__(moduleId) {\n/******/\n/******/ \t\t// Check if module is in cache\n/******/ \t\tif(installedModules[moduleId]) {\n/******/ \t\t\treturn installedModules[moduleId].exports;\n/******/ \t\t}\n/******/ \t\t// Create a new module (and put it into the cache)\n/******/ \t\tvar module = installedModules[moduleId] = {\n/******/ \t\t\ti: moduleId,\n/******/ \t\t\tl: false,\n/******/ \t\t\texports: {}\n/******/ \t\t};\n/******/\n/******/ \t\t// Execute the module function\n/******/ \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n/******/\n/******/ \t\t// Flag the module as loaded\n/******/ \t\tmodule.l = true;\n/******/\n/******/ \t\t// Return the exports of the module\n/******/ \t\treturn module.exports;\n/******/ \t}\n/******/\n/******/\n/******/ \t// expose the modules object (__webpack_modules__)\n/******/ \t__webpack_require__.m = modules;\n/******/\n/******/ \t// expose the module cache\n/******/ \t__webpack_require__.c = installedModules;\n/******/\n/******/ \t// define getter function for harmony exports\n/******/ \t__webpack_require__.d = function(exports, name, getter) {\n/******/ \t\tif(!__webpack_require__.o(exports, name)) {\n/******/ \t\t\tObject.defineProperty(exports, name, {\n/******/ \t\t\t\tconfigurable: false,\n/******/ \t\t\t\tenumerable: true,\n/******/ \t\t\t\tget: getter\n/******/ \t\t\t});\n/******/ \t\t}\n/******/ \t};\n/******/\n/******/ \t// getDefaultExport function for compatibility with non-harmony modules\n/******/ \t__webpack_require__.n = function(module) {\n/******/ \t\tvar getter = module && module.__esModule ?\n/******/ \t\t\tfunction getDefault() { return module['default']; } :\n/******/ \t\t\tfunction getModuleExports() { return module; };\n/******/ \t\t__webpack_require__.d(getter, 'a', getter);\n/******/ \t\treturn getter;\n/******/ \t};\n/******/\n/******/ \t// Object.prototype.hasOwnProperty.call\n/******/ \t__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };\n/******/\n/******/ \t// __webpack_public_path__\n/******/ \t__webpack_require__.p = \"https://static.nrk.no/dh/dh-plastic-counter/static/\";\n/******/\n/******/ \t// Load entry module and return exports\n/******/ \treturn __webpack_require__(__webpack_require__.s = 5);\n/******/ })\n/************************************************************************/\n/******/ ([\n/* 0 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n\tvalue: true\n});\n\nvar _typeof = typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; };\n\n/** Virtual DOM Node */\nfunction VNode() {}\n\n/** Global options\n *\t@public\n *\t@namespace options {Object}\n */\nvar options = {\n\n\t/** If `true`, `prop` changes trigger synchronous component updates.\n  *\t@name syncComponentUpdates\n  *\t@type Boolean\n  *\t@default true\n  */\n\t//syncComponentUpdates: true,\n\n\t/** Processes all created VNodes.\n  *\t@param {VNode} vnode\tA newly-created VNode to normalize/process\n  */\n\t//vnode(vnode) { }\n\n\t/** Hook invoked after a component is mounted. */\n\t// afterMount(component) { }\n\n\t/** Hook invoked after the DOM is updated with a component's latest render. */\n\t// afterUpdate(component) { }\n\n\t/** Hook invoked immediately before a component is unmounted. */\n\t// beforeUnmount(component) { }\n};\n\nvar stack = [];\n\nvar EMPTY_CHILDREN = [];\n\n/**\n * JSX/hyperscript reviver.\n * @see http://jasonformat.com/wtf-is-jsx\n * Benchmarks: https://esbench.com/bench/57ee8f8e330ab09900a1a1a0\n *\n * Note: this is exported as both `h()` and `createElement()` for compatibility reasons.\n *\n * Creates a VNode (virtual DOM element). A tree of VNodes can be used as a lightweight representation\n * of the structure of a DOM tree. This structure can be realized by recursively comparing it against\n * the current _actual_ DOM structure, and applying only the differences.\n *\n * `h()`/`createElement()` accepts an element name, a list of attributes/props,\n * and optionally children to append to the element.\n *\n * @example The following DOM tree\n *\n * `<div id=\"foo\" name=\"bar\">Hello!</div>`\n *\n * can be constructed using this function as:\n *\n * `h('div', { id: 'foo', name : 'bar' }, 'Hello!');`\n *\n * @param {string} nodeName\tAn element name. Ex: `div`, `a`, `span`, etc.\n * @param {Object} attributes\tAny attributes/props to set on the created element.\n * @param rest\t\t\tAdditional arguments are taken to be children to append. Can be infinitely nested Arrays.\n *\n * @public\n */\nfunction h(nodeName, attributes) {\n\tvar children = EMPTY_CHILDREN,\n\t    lastSimple,\n\t    child,\n\t    simple,\n\t    i;\n\tfor (i = arguments.length; i-- > 2;) {\n\t\tstack.push(arguments[i]);\n\t}\n\tif (attributes && attributes.children != null) {\n\t\tif (!stack.length) stack.push(attributes.children);\n\t\tdelete attributes.children;\n\t}\n\twhile (stack.length) {\n\t\tif ((child = stack.pop()) && child.pop !== undefined) {\n\t\t\tfor (i = child.length; i--;) {\n\t\t\t\tstack.push(child[i]);\n\t\t\t}\n\t\t} else {\n\t\t\tif (typeof child === 'boolean') child = null;\n\n\t\t\tif (simple = typeof nodeName !== 'function') {\n\t\t\t\tif (child == null) child = '';else if (typeof child === 'number') child = String(child);else if (typeof child !== 'string') simple = false;\n\t\t\t}\n\n\t\t\tif (simple && lastSimple) {\n\t\t\t\tchildren[children.length - 1] += child;\n\t\t\t} else if (children === EMPTY_CHILDREN) {\n\t\t\t\tchildren = [child];\n\t\t\t} else {\n\t\t\t\tchildren.push(child);\n\t\t\t}\n\n\t\t\tlastSimple = simple;\n\t\t}\n\t}\n\n\tvar p = new VNode();\n\tp.nodeName = nodeName;\n\tp.children = children;\n\tp.attributes = attributes == null ? undefined : attributes;\n\tp.key = attributes == null ? undefined : attributes.key;\n\n\t// if a \"vnode hook\" is defined, pass every created VNode to it\n\tif (options.vnode !== undefined) options.vnode(p);\n\n\treturn p;\n}\n\n/**\n *  Copy all properties from `props` onto `obj`.\n *  @param {Object} obj\t\tObject onto which properties should be copied.\n *  @param {Object} props\tObject from which to copy properties.\n *  @returns obj\n *  @private\n */\nfunction extend(obj, props) {\n\tfor (var i in props) {\n\t\tobj[i] = props[i];\n\t}return obj;\n}\n\n/**\n * Call a function asynchronously, as soon as possible. Makes\n * use of HTML Promise to schedule the callback if available,\n * otherwise falling back to `setTimeout` (mainly for IE<11).\n *\n * @param {Function} callback\n */\nvar defer = typeof Promise == 'function' ? Promise.resolve().then.bind(Promise.resolve()) : setTimeout;\n\n/**\n * Clones the given VNode, optionally adding attributes/props and replacing its children.\n * @param {VNode} vnode\t\tThe virutal DOM element to clone\n * @param {Object} props\tAttributes/props to add when cloning\n * @param {VNode} rest\t\tAny additional arguments will be used as replacement children.\n */\nfunction cloneElement(vnode, props) {\n\treturn h(vnode.nodeName, extend(extend({}, vnode.attributes), props), arguments.length > 2 ? [].slice.call(arguments, 2) : vnode.children);\n}\n\n// DOM properties that should NOT have \"px\" added when numeric\nvar IS_NON_DIMENSIONAL = /acit|ex(?:s|g|n|p|$)|rph|ows|mnc|ntw|ine[ch]|zoo|^ord/i;\n\n/** Managed queue of dirty components to be re-rendered */\n\nvar items = [];\n\nfunction enqueueRender(component) {\n\tif (!component._dirty && (component._dirty = true) && items.push(component) == 1) {\n\t\t(options.debounceRendering || defer)(rerender);\n\t}\n}\n\nfunction rerender() {\n\tvar p,\n\t    list = items;\n\titems = [];\n\twhile (p = list.pop()) {\n\t\tif (p._dirty) renderComponent(p);\n\t}\n}\n\n/**\n * Check if two nodes are equivalent.\n *\n * @param {Node} node\t\t\tDOM Node to compare\n * @param {VNode} vnode\t\t\tVirtual DOM node to compare\n * @param {boolean} [hyrdating=false]\tIf true, ignores component constructors when comparing.\n * @private\n */\nfunction isSameNodeType(node, vnode, hydrating) {\n\tif (typeof vnode === 'string' || typeof vnode === 'number') {\n\t\treturn node.splitText !== undefined;\n\t}\n\tif (typeof vnode.nodeName === 'string') {\n\t\treturn !node._componentConstructor && isNamedNode(node, vnode.nodeName);\n\t}\n\treturn hydrating || node._componentConstructor === vnode.nodeName;\n}\n\n/**\n * Check if an Element has a given nodeName, case-insensitively.\n *\n * @param {Element} node\tA DOM Element to inspect the name of.\n * @param {String} nodeName\tUnnormalized name to compare against.\n */\nfunction isNamedNode(node, nodeName) {\n\treturn node.normalizedNodeName === nodeName || node.nodeName.toLowerCase() === nodeName.toLowerCase();\n}\n\n/**\n * Reconstruct Component-style `props` from a VNode.\n * Ensures default/fallback values from `defaultProps`:\n * Own-properties of `defaultProps` not present in `vnode.attributes` are added.\n *\n * @param {VNode} vnode\n * @returns {Object} props\n */\nfunction getNodeProps(vnode) {\n\tvar props = extend({}, vnode.attributes);\n\tprops.children = vnode.children;\n\n\tvar defaultProps = vnode.nodeName.defaultProps;\n\tif (defaultProps !== undefined) {\n\t\tfor (var i in defaultProps) {\n\t\t\tif (props[i] === undefined) {\n\t\t\t\tprops[i] = defaultProps[i];\n\t\t\t}\n\t\t}\n\t}\n\n\treturn props;\n}\n\n/** Create an element with the given nodeName.\n *\t@param {String} nodeName\n *\t@param {Boolean} [isSvg=false]\tIf `true`, creates an element within the SVG namespace.\n *\t@returns {Element} node\n */\nfunction createNode(nodeName, isSvg) {\n\tvar node = isSvg ? document.createElementNS('http://www.w3.org/2000/svg', nodeName) : document.createElement(nodeName);\n\tnode.normalizedNodeName = nodeName;\n\treturn node;\n}\n\n/** Remove a child node from its parent if attached.\n *\t@param {Element} node\t\tThe node to remove\n */\nfunction removeNode(node) {\n\tvar parentNode = node.parentNode;\n\tif (parentNode) parentNode.removeChild(node);\n}\n\n/** Set a named attribute on the given Node, with special behavior for some names and event handlers.\n *\tIf `value` is `null`, the attribute/handler will be removed.\n *\t@param {Element} node\tAn element to mutate\n *\t@param {string} name\tThe name/key to set, such as an event or attribute name\n *\t@param {any} old\tThe last value that was set for this name/node pair\n *\t@param {any} value\tAn attribute value, such as a function to be used as an event handler\n *\t@param {Boolean} isSvg\tAre we currently diffing inside an svg?\n *\t@private\n */\nfunction setAccessor(node, name, old, value, isSvg) {\n\tif (name === 'className') name = 'class';\n\n\tif (name === 'key') {\n\t\t// ignore\n\t} else if (name === 'ref') {\n\t\tif (old) old(null);\n\t\tif (value) value(node);\n\t} else if (name === 'class' && !isSvg) {\n\t\tnode.className = value || '';\n\t} else if (name === 'style') {\n\t\tif (!value || typeof value === 'string' || typeof old === 'string') {\n\t\t\tnode.style.cssText = value || '';\n\t\t}\n\t\tif (value && (typeof value === 'undefined' ? 'undefined' : _typeof(value)) === 'object') {\n\t\t\tif (typeof old !== 'string') {\n\t\t\t\tfor (var i in old) {\n\t\t\t\t\tif (!(i in value)) node.style[i] = '';\n\t\t\t\t}\n\t\t\t}\n\t\t\tfor (var i in value) {\n\t\t\t\tnode.style[i] = typeof value[i] === 'number' && IS_NON_DIMENSIONAL.test(i) === false ? value[i] + 'px' : value[i];\n\t\t\t}\n\t\t}\n\t} else if (name === 'dangerouslySetInnerHTML') {\n\t\tif (value) node.innerHTML = value.__html || '';\n\t} else if (name[0] == 'o' && name[1] == 'n') {\n\t\tvar useCapture = name !== (name = name.replace(/Capture$/, ''));\n\t\tname = name.toLowerCase().substring(2);\n\t\tif (value) {\n\t\t\tif (!old) node.addEventListener(name, eventProxy, useCapture);\n\t\t} else {\n\t\t\tnode.removeEventListener(name, eventProxy, useCapture);\n\t\t}\n\t\t(node._listeners || (node._listeners = {}))[name] = value;\n\t} else if (name !== 'list' && name !== 'type' && !isSvg && name in node) {\n\t\tsetProperty(node, name, value == null ? '' : value);\n\t\tif (value == null || value === false) node.removeAttribute(name);\n\t} else {\n\t\tvar ns = isSvg && name !== (name = name.replace(/^xlink\\:?/, ''));\n\t\tif (value == null || value === false) {\n\t\t\tif (ns) node.removeAttributeNS('http://www.w3.org/1999/xlink', name.toLowerCase());else node.removeAttribute(name);\n\t\t} else if (typeof value !== 'function') {\n\t\t\tif (ns) node.setAttributeNS('http://www.w3.org/1999/xlink', name.toLowerCase(), value);else node.setAttribute(name, value);\n\t\t}\n\t}\n}\n\n/** Attempt to set a DOM property to the given value.\n *\tIE & FF throw for certain property-value combinations.\n */\nfunction setProperty(node, name, value) {\n\ttry {\n\t\tnode[name] = value;\n\t} catch (e) {}\n}\n\n/** Proxy an event to hooked event handlers\n *\t@private\n */\nfunction eventProxy(e) {\n\treturn this._listeners[e.type](options.event && options.event(e) || e);\n}\n\n/** Queue of components that have been mounted and are awaiting componentDidMount */\nvar mounts = [];\n\n/** Diff recursion count, used to track the end of the diff cycle. */\nvar diffLevel = 0;\n\n/** Global flag indicating if the diff is currently within an SVG */\nvar isSvgMode = false;\n\n/** Global flag indicating if the diff is performing hydration */\nvar hydrating = false;\n\n/** Invoke queued componentDidMount lifecycle methods */\nfunction flushMounts() {\n\tvar c;\n\twhile (c = mounts.pop()) {\n\t\tif (options.afterMount) options.afterMount(c);\n\t\tif (c.componentDidMount) c.componentDidMount();\n\t}\n}\n\n/** Apply differences in a given vnode (and it's deep children) to a real DOM Node.\n *\t@param {Element} [dom=null]\t\tA DOM node to mutate into the shape of the `vnode`\n *\t@param {VNode} vnode\t\t\tA VNode (with descendants forming a tree) representing the desired DOM structure\n *\t@returns {Element} dom\t\t\tThe created/mutated element\n *\t@private\n */\nfunction diff(dom, vnode, context, mountAll, parent, componentRoot) {\n\t// diffLevel having been 0 here indicates initial entry into the diff (not a subdiff)\n\tif (!diffLevel++) {\n\t\t// when first starting the diff, check if we're diffing an SVG or within an SVG\n\t\tisSvgMode = parent != null && parent.ownerSVGElement !== undefined;\n\n\t\t// hydration is indicated by the existing element to be diffed not having a prop cache\n\t\thydrating = dom != null && !('__preactattr_' in dom);\n\t}\n\n\tvar ret = idiff(dom, vnode, context, mountAll, componentRoot);\n\n\t// append the element if its a new parent\n\tif (parent && ret.parentNode !== parent) parent.appendChild(ret);\n\n\t// diffLevel being reduced to 0 means we're exiting the diff\n\tif (! --diffLevel) {\n\t\thydrating = false;\n\t\t// invoke queued componentDidMount lifecycle methods\n\t\tif (!componentRoot) flushMounts();\n\t}\n\n\treturn ret;\n}\n\n/** Internals of `diff()`, separated to allow bypassing diffLevel / mount flushing. */\nfunction idiff(dom, vnode, context, mountAll, componentRoot) {\n\tvar out = dom,\n\t    prevSvgMode = isSvgMode;\n\n\t// empty values (null, undefined, booleans) render as empty Text nodes\n\tif (vnode == null || typeof vnode === 'boolean') vnode = '';\n\n\t// Fast case: Strings & Numbers create/update Text nodes.\n\tif (typeof vnode === 'string' || typeof vnode === 'number') {\n\n\t\t// update if it's already a Text node:\n\t\tif (dom && dom.splitText !== undefined && dom.parentNode && (!dom._component || componentRoot)) {\n\t\t\t/* istanbul ignore if */ /* Browser quirk that can't be covered: https://github.com/developit/preact/commit/fd4f21f5c45dfd75151bd27b4c217d8003aa5eb9 */\n\t\t\tif (dom.nodeValue != vnode) {\n\t\t\t\tdom.nodeValue = vnode;\n\t\t\t}\n\t\t} else {\n\t\t\t// it wasn't a Text node: replace it with one and recycle the old Element\n\t\t\tout = document.createTextNode(vnode);\n\t\t\tif (dom) {\n\t\t\t\tif (dom.parentNode) dom.parentNode.replaceChild(out, dom);\n\t\t\t\trecollectNodeTree(dom, true);\n\t\t\t}\n\t\t}\n\n\t\tout['__preactattr_'] = true;\n\n\t\treturn out;\n\t}\n\n\t// If the VNode represents a Component, perform a component diff:\n\tvar vnodeName = vnode.nodeName;\n\tif (typeof vnodeName === 'function') {\n\t\treturn buildComponentFromVNode(dom, vnode, context, mountAll);\n\t}\n\n\t// Tracks entering and exiting SVG namespace when descending through the tree.\n\tisSvgMode = vnodeName === 'svg' ? true : vnodeName === 'foreignObject' ? false : isSvgMode;\n\n\t// If there's no existing element or it's the wrong type, create a new one:\n\tvnodeName = String(vnodeName);\n\tif (!dom || !isNamedNode(dom, vnodeName)) {\n\t\tout = createNode(vnodeName, isSvgMode);\n\n\t\tif (dom) {\n\t\t\t// move children into the replacement node\n\t\t\twhile (dom.firstChild) {\n\t\t\t\tout.appendChild(dom.firstChild);\n\t\t\t} // if the previous Element was mounted into the DOM, replace it inline\n\t\t\tif (dom.parentNode) dom.parentNode.replaceChild(out, dom);\n\n\t\t\t// recycle the old element (skips non-Element node types)\n\t\t\trecollectNodeTree(dom, true);\n\t\t}\n\t}\n\n\tvar fc = out.firstChild,\n\t    props = out['__preactattr_'],\n\t    vchildren = vnode.children;\n\n\tif (props == null) {\n\t\tprops = out['__preactattr_'] = {};\n\t\tfor (var a = out.attributes, i = a.length; i--;) {\n\t\t\tprops[a[i].name] = a[i].value;\n\t\t}\n\t}\n\n\t// Optimization: fast-path for elements containing a single TextNode:\n\tif (!hydrating && vchildren && vchildren.length === 1 && typeof vchildren[0] === 'string' && fc != null && fc.splitText !== undefined && fc.nextSibling == null) {\n\t\tif (fc.nodeValue != vchildren[0]) {\n\t\t\tfc.nodeValue = vchildren[0];\n\t\t}\n\t}\n\t// otherwise, if there are existing or new children, diff them:\n\telse if (vchildren && vchildren.length || fc != null) {\n\t\t\tinnerDiffNode(out, vchildren, context, mountAll, hydrating || props.dangerouslySetInnerHTML != null);\n\t\t}\n\n\t// Apply attributes/props from VNode to the DOM Element:\n\tdiffAttributes(out, vnode.attributes, props);\n\n\t// restore previous SVG mode: (in case we're exiting an SVG namespace)\n\tisSvgMode = prevSvgMode;\n\n\treturn out;\n}\n\n/** Apply child and attribute changes between a VNode and a DOM Node to the DOM.\n *\t@param {Element} dom\t\t\tElement whose children should be compared & mutated\n *\t@param {Array} vchildren\t\tArray of VNodes to compare to `dom.childNodes`\n *\t@param {Object} context\t\t\tImplicitly descendant context object (from most recent `getChildContext()`)\n *\t@param {Boolean} mountAll\n *\t@param {Boolean} isHydrating\tIf `true`, consumes externally created elements similar to hydration\n */\nfunction innerDiffNode(dom, vchildren, context, mountAll, isHydrating) {\n\tvar originalChildren = dom.childNodes,\n\t    children = [],\n\t    keyed = {},\n\t    keyedLen = 0,\n\t    min = 0,\n\t    len = originalChildren.length,\n\t    childrenLen = 0,\n\t    vlen = vchildren ? vchildren.length : 0,\n\t    j,\n\t    c,\n\t    f,\n\t    vchild,\n\t    child;\n\n\t// Build up a map of keyed children and an Array of unkeyed children:\n\tif (len !== 0) {\n\t\tfor (var i = 0; i < len; i++) {\n\t\t\tvar _child = originalChildren[i],\n\t\t\t    props = _child['__preactattr_'],\n\t\t\t    key = vlen && props ? _child._component ? _child._component.__key : props.key : null;\n\t\t\tif (key != null) {\n\t\t\t\tkeyedLen++;\n\t\t\t\tkeyed[key] = _child;\n\t\t\t} else if (props || (_child.splitText !== undefined ? isHydrating ? _child.nodeValue.trim() : true : isHydrating)) {\n\t\t\t\tchildren[childrenLen++] = _child;\n\t\t\t}\n\t\t}\n\t}\n\n\tif (vlen !== 0) {\n\t\tfor (var i = 0; i < vlen; i++) {\n\t\t\tvchild = vchildren[i];\n\t\t\tchild = null;\n\n\t\t\t// attempt to find a node based on key matching\n\t\t\tvar key = vchild.key;\n\t\t\tif (key != null) {\n\t\t\t\tif (keyedLen && keyed[key] !== undefined) {\n\t\t\t\t\tchild = keyed[key];\n\t\t\t\t\tkeyed[key] = undefined;\n\t\t\t\t\tkeyedLen--;\n\t\t\t\t}\n\t\t\t}\n\t\t\t// attempt to pluck a node of the same type from the existing children\n\t\t\telse if (!child && min < childrenLen) {\n\t\t\t\t\tfor (j = min; j < childrenLen; j++) {\n\t\t\t\t\t\tif (children[j] !== undefined && isSameNodeType(c = children[j], vchild, isHydrating)) {\n\t\t\t\t\t\t\tchild = c;\n\t\t\t\t\t\t\tchildren[j] = undefined;\n\t\t\t\t\t\t\tif (j === childrenLen - 1) childrenLen--;\n\t\t\t\t\t\t\tif (j === min) min++;\n\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t// morph the matched/found/created DOM child to match vchild (deep)\n\t\t\tchild = idiff(child, vchild, context, mountAll);\n\n\t\t\tf = originalChildren[i];\n\t\t\tif (child && child !== dom && child !== f) {\n\t\t\t\tif (f == null) {\n\t\t\t\t\tdom.appendChild(child);\n\t\t\t\t} else if (child === f.nextSibling) {\n\t\t\t\t\tremoveNode(f);\n\t\t\t\t} else {\n\t\t\t\t\tdom.insertBefore(child, f);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\t// remove unused keyed children:\n\tif (keyedLen) {\n\t\tfor (var i in keyed) {\n\t\t\tif (keyed[i] !== undefined) recollectNodeTree(keyed[i], false);\n\t\t}\n\t}\n\n\t// remove orphaned unkeyed children:\n\twhile (min <= childrenLen) {\n\t\tif ((child = children[childrenLen--]) !== undefined) recollectNodeTree(child, false);\n\t}\n}\n\n/** Recursively recycle (or just unmount) a node and its descendants.\n *\t@param {Node} node\t\t\t\t\t\tDOM node to start unmount/removal from\n *\t@param {Boolean} [unmountOnly=false]\tIf `true`, only triggers unmount lifecycle, skips removal\n */\nfunction recollectNodeTree(node, unmountOnly) {\n\tvar component = node._component;\n\tif (component) {\n\t\t// if node is owned by a Component, unmount that component (ends up recursing back here)\n\t\tunmountComponent(component);\n\t} else {\n\t\t// If the node's VNode had a ref function, invoke it with null here.\n\t\t// (this is part of the React spec, and smart for unsetting references)\n\t\tif (node['__preactattr_'] != null && node['__preactattr_'].ref) node['__preactattr_'].ref(null);\n\n\t\tif (unmountOnly === false || node['__preactattr_'] == null) {\n\t\t\tremoveNode(node);\n\t\t}\n\n\t\tremoveChildren(node);\n\t}\n}\n\n/** Recollect/unmount all children.\n *\t- we use .lastChild here because it causes less reflow than .firstChild\n *\t- it's also cheaper than accessing the .childNodes Live NodeList\n */\nfunction removeChildren(node) {\n\tnode = node.lastChild;\n\twhile (node) {\n\t\tvar next = node.previousSibling;\n\t\trecollectNodeTree(node, true);\n\t\tnode = next;\n\t}\n}\n\n/** Apply differences in attributes from a VNode to the given DOM Element.\n *\t@param {Element} dom\t\tElement with attributes to diff `attrs` against\n *\t@param {Object} attrs\t\tThe desired end-state key-value attribute pairs\n *\t@param {Object} old\t\t\tCurrent/previous attributes (from previous VNode or element's prop cache)\n */\nfunction diffAttributes(dom, attrs, old) {\n\tvar name;\n\n\t// remove attributes no longer present on the vnode by setting them to undefined\n\tfor (name in old) {\n\t\tif (!(attrs && attrs[name] != null) && old[name] != null) {\n\t\t\tsetAccessor(dom, name, old[name], old[name] = undefined, isSvgMode);\n\t\t}\n\t}\n\n\t// add new & update changed attributes\n\tfor (name in attrs) {\n\t\tif (name !== 'children' && name !== 'innerHTML' && (!(name in old) || attrs[name] !== (name === 'value' || name === 'checked' ? dom[name] : old[name]))) {\n\t\t\tsetAccessor(dom, name, old[name], old[name] = attrs[name], isSvgMode);\n\t\t}\n\t}\n}\n\n/** Retains a pool of Components for re-use, keyed on component name.\n *\tNote: since component names are not unique or even necessarily available, these are primarily a form of sharding.\n *\t@private\n */\nvar components = {};\n\n/** Reclaim a component for later re-use by the recycler. */\nfunction collectComponent(component) {\n\tvar name = component.constructor.name;\n\t(components[name] || (components[name] = [])).push(component);\n}\n\n/** Create a component. Normalizes differences between PFC's and classful Components. */\nfunction createComponent(Ctor, props, context) {\n\tvar list = components[Ctor.name],\n\t    inst;\n\n\tif (Ctor.prototype && Ctor.prototype.render) {\n\t\tinst = new Ctor(props, context);\n\t\tComponent.call(inst, props, context);\n\t} else {\n\t\tinst = new Component(props, context);\n\t\tinst.constructor = Ctor;\n\t\tinst.render = doRender;\n\t}\n\n\tif (list) {\n\t\tfor (var i = list.length; i--;) {\n\t\t\tif (list[i].constructor === Ctor) {\n\t\t\t\tinst.nextBase = list[i].nextBase;\n\t\t\t\tlist.splice(i, 1);\n\t\t\t\tbreak;\n\t\t\t}\n\t\t}\n\t}\n\treturn inst;\n}\n\n/** The `.render()` method for a PFC backing instance. */\nfunction doRender(props, state, context) {\n\treturn this.constructor(props, context);\n}\n\n/** Set a component's `props` (generally derived from JSX attributes).\n *\t@param {Object} props\n *\t@param {Object} [opts]\n *\t@param {boolean} [opts.renderSync=false]\tIf `true` and {@link options.syncComponentUpdates} is `true`, triggers synchronous rendering.\n *\t@param {boolean} [opts.render=true]\t\t\tIf `false`, no render will be triggered.\n */\nfunction setComponentProps(component, props, opts, context, mountAll) {\n\tif (component._disable) return;\n\tcomponent._disable = true;\n\n\tif (component.__ref = props.ref) delete props.ref;\n\tif (component.__key = props.key) delete props.key;\n\n\tif (!component.base || mountAll) {\n\t\tif (component.componentWillMount) component.componentWillMount();\n\t} else if (component.componentWillReceiveProps) {\n\t\tcomponent.componentWillReceiveProps(props, context);\n\t}\n\n\tif (context && context !== component.context) {\n\t\tif (!component.prevContext) component.prevContext = component.context;\n\t\tcomponent.context = context;\n\t}\n\n\tif (!component.prevProps) component.prevProps = component.props;\n\tcomponent.props = props;\n\n\tcomponent._disable = false;\n\n\tif (opts !== 0) {\n\t\tif (opts === 1 || options.syncComponentUpdates !== false || !component.base) {\n\t\t\trenderComponent(component, 1, mountAll);\n\t\t} else {\n\t\t\tenqueueRender(component);\n\t\t}\n\t}\n\n\tif (component.__ref) component.__ref(component);\n}\n\n/** Render a Component, triggering necessary lifecycle events and taking High-Order Components into account.\n *\t@param {Component} component\n *\t@param {Object} [opts]\n *\t@param {boolean} [opts.build=false]\t\tIf `true`, component will build and store a DOM node if not already associated with one.\n *\t@private\n */\nfunction renderComponent(component, opts, mountAll, isChild) {\n\tif (component._disable) return;\n\n\tvar props = component.props,\n\t    state = component.state,\n\t    context = component.context,\n\t    previousProps = component.prevProps || props,\n\t    previousState = component.prevState || state,\n\t    previousContext = component.prevContext || context,\n\t    isUpdate = component.base,\n\t    nextBase = component.nextBase,\n\t    initialBase = isUpdate || nextBase,\n\t    initialChildComponent = component._component,\n\t    skip = false,\n\t    rendered,\n\t    inst,\n\t    cbase;\n\n\t// if updating\n\tif (isUpdate) {\n\t\tcomponent.props = previousProps;\n\t\tcomponent.state = previousState;\n\t\tcomponent.context = previousContext;\n\t\tif (opts !== 2 && component.shouldComponentUpdate && component.shouldComponentUpdate(props, state, context) === false) {\n\t\t\tskip = true;\n\t\t} else if (component.componentWillUpdate) {\n\t\t\tcomponent.componentWillUpdate(props, state, context);\n\t\t}\n\t\tcomponent.props = props;\n\t\tcomponent.state = state;\n\t\tcomponent.context = context;\n\t}\n\n\tcomponent.prevProps = component.prevState = component.prevContext = component.nextBase = null;\n\tcomponent._dirty = false;\n\n\tif (!skip) {\n\t\trendered = component.render(props, state, context);\n\n\t\t// context to pass to the child, can be updated via (grand-)parent component\n\t\tif (component.getChildContext) {\n\t\t\tcontext = extend(extend({}, context), component.getChildContext());\n\t\t}\n\n\t\tvar childComponent = rendered && rendered.nodeName,\n\t\t    toUnmount,\n\t\t    base;\n\n\t\tif (typeof childComponent === 'function') {\n\t\t\t// set up high order component link\n\n\t\t\tvar childProps = getNodeProps(rendered);\n\t\t\tinst = initialChildComponent;\n\n\t\t\tif (inst && inst.constructor === childComponent && childProps.key == inst.__key) {\n\t\t\t\tsetComponentProps(inst, childProps, 1, context, false);\n\t\t\t} else {\n\t\t\t\ttoUnmount = inst;\n\n\t\t\t\tcomponent._component = inst = createComponent(childComponent, childProps, context);\n\t\t\t\tinst.nextBase = inst.nextBase || nextBase;\n\t\t\t\tinst._parentComponent = component;\n\t\t\t\tsetComponentProps(inst, childProps, 0, context, false);\n\t\t\t\trenderComponent(inst, 1, mountAll, true);\n\t\t\t}\n\n\t\t\tbase = inst.base;\n\t\t} else {\n\t\t\tcbase = initialBase;\n\n\t\t\t// destroy high order component link\n\t\t\ttoUnmount = initialChildComponent;\n\t\t\tif (toUnmount) {\n\t\t\t\tcbase = component._component = null;\n\t\t\t}\n\n\t\t\tif (initialBase || opts === 1) {\n\t\t\t\tif (cbase) cbase._component = null;\n\t\t\t\tbase = diff(cbase, rendered, context, mountAll || !isUpdate, initialBase && initialBase.parentNode, true);\n\t\t\t}\n\t\t}\n\n\t\tif (initialBase && base !== initialBase && inst !== initialChildComponent) {\n\t\t\tvar baseParent = initialBase.parentNode;\n\t\t\tif (baseParent && base !== baseParent) {\n\t\t\t\tbaseParent.replaceChild(base, initialBase);\n\n\t\t\t\tif (!toUnmount) {\n\t\t\t\t\tinitialBase._component = null;\n\t\t\t\t\trecollectNodeTree(initialBase, false);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\tif (toUnmount) {\n\t\t\tunmountComponent(toUnmount);\n\t\t}\n\n\t\tcomponent.base = base;\n\t\tif (base && !isChild) {\n\t\t\tvar componentRef = component,\n\t\t\t    t = component;\n\t\t\twhile (t = t._parentComponent) {\n\t\t\t\t(componentRef = t).base = base;\n\t\t\t}\n\t\t\tbase._component = componentRef;\n\t\t\tbase._componentConstructor = componentRef.constructor;\n\t\t}\n\t}\n\n\tif (!isUpdate || mountAll) {\n\t\tmounts.unshift(component);\n\t} else if (!skip) {\n\t\t// Ensure that pending componentDidMount() hooks of child components\n\t\t// are called before the componentDidUpdate() hook in the parent.\n\t\t// Note: disabled as it causes duplicate hooks, see https://github.com/developit/preact/issues/750\n\t\t// flushMounts();\n\n\t\tif (component.componentDidUpdate) {\n\t\t\tcomponent.componentDidUpdate(previousProps, previousState, previousContext);\n\t\t}\n\t\tif (options.afterUpdate) options.afterUpdate(component);\n\t}\n\n\tif (component._renderCallbacks != null) {\n\t\twhile (component._renderCallbacks.length) {\n\t\t\tcomponent._renderCallbacks.pop().call(component);\n\t\t}\n\t}\n\n\tif (!diffLevel && !isChild) flushMounts();\n}\n\n/** Apply the Component referenced by a VNode to the DOM.\n *\t@param {Element} dom\tThe DOM node to mutate\n *\t@param {VNode} vnode\tA Component-referencing VNode\n *\t@returns {Element} dom\tThe created/mutated element\n *\t@private\n */\nfunction buildComponentFromVNode(dom, vnode, context, mountAll) {\n\tvar c = dom && dom._component,\n\t    originalComponent = c,\n\t    oldDom = dom,\n\t    isDirectOwner = c && dom._componentConstructor === vnode.nodeName,\n\t    isOwner = isDirectOwner,\n\t    props = getNodeProps(vnode);\n\twhile (c && !isOwner && (c = c._parentComponent)) {\n\t\tisOwner = c.constructor === vnode.nodeName;\n\t}\n\n\tif (c && isOwner && (!mountAll || c._component)) {\n\t\tsetComponentProps(c, props, 3, context, mountAll);\n\t\tdom = c.base;\n\t} else {\n\t\tif (originalComponent && !isDirectOwner) {\n\t\t\tunmountComponent(originalComponent);\n\t\t\tdom = oldDom = null;\n\t\t}\n\n\t\tc = createComponent(vnode.nodeName, props, context);\n\t\tif (dom && !c.nextBase) {\n\t\t\tc.nextBase = dom;\n\t\t\t// passing dom/oldDom as nextBase will recycle it if unused, so bypass recycling on L229:\n\t\t\toldDom = null;\n\t\t}\n\t\tsetComponentProps(c, props, 1, context, mountAll);\n\t\tdom = c.base;\n\n\t\tif (oldDom && dom !== oldDom) {\n\t\t\toldDom._component = null;\n\t\t\trecollectNodeTree(oldDom, false);\n\t\t}\n\t}\n\n\treturn dom;\n}\n\n/** Remove a component from the DOM and recycle it.\n *\t@param {Component} component\tThe Component instance to unmount\n *\t@private\n */\nfunction unmountComponent(component) {\n\tif (options.beforeUnmount) options.beforeUnmount(component);\n\n\tvar base = component.base;\n\n\tcomponent._disable = true;\n\n\tif (component.componentWillUnmount) component.componentWillUnmount();\n\n\tcomponent.base = null;\n\n\t// recursively tear down & recollect high-order component children:\n\tvar inner = component._component;\n\tif (inner) {\n\t\tunmountComponent(inner);\n\t} else if (base) {\n\t\tif (base['__preactattr_'] && base['__preactattr_'].ref) base['__preactattr_'].ref(null);\n\n\t\tcomponent.nextBase = base;\n\n\t\tremoveNode(base);\n\t\tcollectComponent(component);\n\n\t\tremoveChildren(base);\n\t}\n\n\tif (component.__ref) component.__ref(null);\n}\n\n/** Base Component class.\n *\tProvides `setState()` and `forceUpdate()`, which trigger rendering.\n *\t@public\n *\n *\t@example\n *\tclass MyFoo extends Component {\n *\t\trender(props, state) {\n *\t\t\treturn <div />;\n *\t\t}\n *\t}\n */\nfunction Component(props, context) {\n\tthis._dirty = true;\n\n\t/** @public\n  *\t@type {object}\n  */\n\tthis.context = context;\n\n\t/** @public\n  *\t@type {object}\n  */\n\tthis.props = props;\n\n\t/** @public\n  *\t@type {object}\n  */\n\tthis.state = this.state || {};\n}\n\nextend(Component.prototype, {\n\n\t/** Returns a `boolean` indicating if the component should re-render when receiving the given `props` and `state`.\n  *\t@param {object} nextProps\n  *\t@param {object} nextState\n  *\t@param {object} nextContext\n  *\t@returns {Boolean} should the component re-render\n  *\t@name shouldComponentUpdate\n  *\t@function\n  */\n\n\t/** Update component state by copying properties from `state` to `this.state`.\n  *\t@param {object} state\t\tA hash of state properties to update with new values\n  *\t@param {function} callback\tA function to be called once component state is updated\n  */\n\tsetState: function setState(state, callback) {\n\t\tvar s = this.state;\n\t\tif (!this.prevState) this.prevState = extend({}, s);\n\t\textend(s, typeof state === 'function' ? state(s, this.props) : state);\n\t\tif (callback) (this._renderCallbacks = this._renderCallbacks || []).push(callback);\n\t\tenqueueRender(this);\n\t},\n\n\t/** Immediately perform a synchronous re-render of the component.\n  *\t@param {function} callback\t\tA function to be called after component is re-rendered.\n  *\t@private\n  */\n\tforceUpdate: function forceUpdate(callback) {\n\t\tif (callback) (this._renderCallbacks = this._renderCallbacks || []).push(callback);\n\t\trenderComponent(this, 2);\n\t},\n\n\t/** Accepts `props` and `state`, and returns a new Virtual DOM tree to build.\n  *\tVirtual DOM is generally constructed via [JSX](http://jasonformat.com/wtf-is-jsx).\n  *\t@param {object} props\t\tProps (eg: JSX attributes) received from parent element/component\n  *\t@param {object} state\t\tThe component's current state\n  *\t@param {object} context\t\tContext object (if a parent component has provided context)\n  *\t@returns VNode\n  */\n\trender: function render() {}\n});\n\n/** Render JSX into a `parent` Element.\n *\t@param {VNode} vnode\t\tA (JSX) VNode to render\n *\t@param {Element} parent\t\tDOM element to render into\n *\t@param {Element} [merge]\tAttempt to re-use an existing DOM tree rooted at `merge`\n *\t@public\n *\n *\t@example\n *\t// render a div into <body>:\n *\trender(<div id=\"hello\">hello!</div>, document.body);\n *\n *\t@example\n *\t// render a \"Thing\" component into #foo:\n *\tconst Thing = ({ name }) => <span>{ name }</span>;\n *\trender(<Thing name=\"one\" />, document.querySelector('#foo'));\n */\nfunction render(vnode, parent, merge) {\n\treturn diff(merge, vnode, {}, false, parent, false);\n}\n\nvar preact = {\n\th: h,\n\tcreateElement: h,\n\tcloneElement: cloneElement,\n\tComponent: Component,\n\trender: render,\n\trerender: rerender,\n\toptions: options\n};\n\nexports.h = h;\nexports.createElement = h;\nexports.cloneElement = cloneElement;\nexports.Component = Component;\nexports.render = render;\nexports.rerender = rerender;\nexports.options = options;\nexports.default = preact;\n//# sourceMappingURL=preact.esm.js.map\n\n/***/ }),\n/* 1 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar _typeof = typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; };\n\nvar g;\n\n// This works in non-strict mode\ng = function () {\n\treturn this;\n}();\n\ntry {\n\t// This works if eval is allowed (see CSP)\n\tg = g || Function(\"return this\")() || (1, eval)(\"this\");\n} catch (e) {\n\t// This works if the window reference is available\n\tif ((typeof window === \"undefined\" ? \"undefined\" : _typeof(window)) === \"object\") g = window;\n}\n\n// g can still be undefined, but nothing to do about it...\n// We return undefined, instead of nothing here, so it's\n// easier to handle this case. if(!global) { ...}\n\nmodule.exports = g;\n\n/***/ }),\n/* 2 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.bem = bem;\nfunction bem(blockName) {\n  for (var _len = arguments.length, modifiers = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {\n    modifiers[_key - 1] = arguments[_key];\n  }\n\n  return [blockName].concat(modifiers.filter(Boolean).map(function (modifier) {\n    return blockName + '--' + modifier;\n  })).join(' ');\n}\n\n/***/ }),\n/* 3 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.connect = exports.Provider = undefined;\n\nvar _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };\n\nvar _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();\n\nvar _preact = __webpack_require__(0);\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return call && (typeof call === \"object\" || typeof call === \"function\") ? call : self; }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function, not \" + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } //  @jsx h\n\n\nvar Provider = function (_Component) {\n  _inherits(Provider, _Component);\n\n  function Provider() {\n    _classCallCheck(this, Provider);\n\n    return _possibleConstructorReturn(this, (Provider.__proto__ || Object.getPrototypeOf(Provider)).apply(this, arguments));\n  }\n\n  _createClass(Provider, [{\n    key: 'getChildContext',\n    value: function getChildContext() {\n      return {\n        sendErrorReport: this.props.sendErrorReport,\n        trackAction: this.props.trackAction\n      };\n    }\n  }, {\n    key: 'render',\n    value: function render() {\n      return this.props.children[0];\n    }\n  }]);\n\n  return Provider;\n}(_preact.Component);\n\nProvider.displayName = 'Provider';\n\nfunction connect(mapStateToProps) {\n  return function (wrappedComponent) {\n    var Connected = function (_Component2) {\n      _inherits(Connected, _Component2);\n\n      function Connected() {\n        var _ref;\n\n        var _temp, _this2, _ret;\n\n        _classCallCheck(this, Connected);\n\n        for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {\n          args[_key] = arguments[_key];\n        }\n\n        return _ret = (_temp = (_this2 = _possibleConstructorReturn(this, (_ref = Connected.__proto__ || Object.getPrototypeOf(Connected)).call.apply(_ref, [this].concat(args))), _this2), _this2.mapStateToProps = function (opts) {\n          return mapStateToProps ? mapStateToProps(opts) : opts;\n        }, _temp), _possibleConstructorReturn(_this2, _ret);\n      }\n\n      _createClass(Connected, [{\n        key: 'render',\n        value: function render() {\n          return (0, _preact.h)(wrappedComponent, _extends({}, this.mapStateToProps({\n            sendErrorReport: this.context.sendErrorReport,\n            trackAction: this.context.trackAction\n          }), this.props));\n        }\n      }]);\n\n      return Connected;\n    }(_preact.Component);\n\n    Connected.displayName = 'connect(' + (wrappedComponent.displayName || wrappedComponent.name || 'Component') + ')';\n    return Connected;\n  };\n}\n\nexports.Provider = Provider;\nexports.connect = connect;\n\n/***/ }),\n/* 4 */\n/***/ (function(module, exports) {\n\n// removed by extract-text-webpack-plugin\nmodule.exports = {\"root\":\"dh-dh-plastic-counter-root\",\"app\":\"dh-dh-plastic-counter-app\",\"app--medium\":\"dh-dh-plastic-counter-app--medium\",\"app--large\":\"dh-dh-plastic-counter-app--large\",\"app--extra-large\":\"dh-dh-plastic-counter-app--extra-large\"};\n\n/***/ }),\n/* 5 */\n/***/ (function(module, exports, __webpack_require__) {\n\n__webpack_require__(6);\nmodule.exports = __webpack_require__(13);\n\n\n/***/ }),\n/* 6 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\n__webpack_require__(7);\n\n__webpack_require__(12);\n\n/***/ }),\n/* 7 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar _index = __webpack_require__(8);\n\nvar _index2 = _interopRequireDefault(_index);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nvar global = function () {\n  // the only reliable means to get the global object is\n  // `Function('return this')()`\n  // However, this causes CSP violations in Chrome apps.\n  if (typeof self !== 'undefined') {\n    return self;\n  }\n  if (typeof window !== 'undefined') {\n    return window;\n  }\n  if (typeof global !== 'undefined') {\n    return global;\n  }\n  throw new Error('unable to locate global object');\n}();\n\nif (!global.Promise) {\n  global.Promise = _index2.default;\n}\n\n/***/ }),\n/* 8 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/* WEBPACK VAR INJECTION */(function(setImmediate) {\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\n\nvar _typeof = typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; };\n\n// Store setTimeout reference so promise-polyfill will be unaffected by\n// other code modifying setTimeout (like sinon.useFakeTimers())\nvar setTimeoutFunc = setTimeout;\n\nfunction noop() {}\n\n// Polyfill for Function.prototype.bind\nfunction bind(fn, thisArg) {\n  return function () {\n    fn.apply(thisArg, arguments);\n  };\n}\n\nfunction Promise(fn) {\n  if (!(this instanceof Promise)) throw new TypeError('Promises must be constructed via new');\n  if (typeof fn !== 'function') throw new TypeError('not a function');\n  this._state = 0;\n  this._handled = false;\n  this._value = undefined;\n  this._deferreds = [];\n\n  doResolve(fn, this);\n}\n\nfunction handle(self, deferred) {\n  while (self._state === 3) {\n    self = self._value;\n  }\n  if (self._state === 0) {\n    self._deferreds.push(deferred);\n    return;\n  }\n  self._handled = true;\n  Promise._immediateFn(function () {\n    var cb = self._state === 1 ? deferred.onFulfilled : deferred.onRejected;\n    if (cb === null) {\n      (self._state === 1 ? resolve : reject)(deferred.promise, self._value);\n      return;\n    }\n    var ret;\n    try {\n      ret = cb(self._value);\n    } catch (e) {\n      reject(deferred.promise, e);\n      return;\n    }\n    resolve(deferred.promise, ret);\n  });\n}\n\nfunction resolve(self, newValue) {\n  try {\n    // Promise Resolution Procedure: https://github.com/promises-aplus/promises-spec#the-promise-resolution-procedure\n    if (newValue === self) throw new TypeError('A promise cannot be resolved with itself.');\n    if (newValue && ((typeof newValue === 'undefined' ? 'undefined' : _typeof(newValue)) === 'object' || typeof newValue === 'function')) {\n      var then = newValue.then;\n      if (newValue instanceof Promise) {\n        self._state = 3;\n        self._value = newValue;\n        finale(self);\n        return;\n      } else if (typeof then === 'function') {\n        doResolve(bind(then, newValue), self);\n        return;\n      }\n    }\n    self._state = 1;\n    self._value = newValue;\n    finale(self);\n  } catch (e) {\n    reject(self, e);\n  }\n}\n\nfunction reject(self, newValue) {\n  self._state = 2;\n  self._value = newValue;\n  finale(self);\n}\n\nfunction finale(self) {\n  if (self._state === 2 && self._deferreds.length === 0) {\n    Promise._immediateFn(function () {\n      if (!self._handled) {\n        Promise._unhandledRejectionFn(self._value);\n      }\n    });\n  }\n\n  for (var i = 0, len = self._deferreds.length; i < len; i++) {\n    handle(self, self._deferreds[i]);\n  }\n  self._deferreds = null;\n}\n\nfunction Handler(onFulfilled, onRejected, promise) {\n  this.onFulfilled = typeof onFulfilled === 'function' ? onFulfilled : null;\n  this.onRejected = typeof onRejected === 'function' ? onRejected : null;\n  this.promise = promise;\n}\n\n/**\n * Take a potentially misbehaving resolver function and make sure\n * onFulfilled and onRejected are only called once.\n *\n * Makes no guarantees about asynchrony.\n */\nfunction doResolve(fn, self) {\n  var done = false;\n  try {\n    fn(function (value) {\n      if (done) return;\n      done = true;\n      resolve(self, value);\n    }, function (reason) {\n      if (done) return;\n      done = true;\n      reject(self, reason);\n    });\n  } catch (ex) {\n    if (done) return;\n    done = true;\n    reject(self, ex);\n  }\n}\n\nPromise.prototype['catch'] = function (onRejected) {\n  return this.then(null, onRejected);\n};\n\nPromise.prototype.then = function (onFulfilled, onRejected) {\n  var prom = new this.constructor(noop);\n\n  handle(this, new Handler(onFulfilled, onRejected, prom));\n  return prom;\n};\n\nPromise.prototype['finally'] = function (callback) {\n  var constructor = this.constructor;\n  return this.then(function (value) {\n    return constructor.resolve(callback()).then(function () {\n      return value;\n    });\n  }, function (reason) {\n    return constructor.resolve(callback()).then(function () {\n      return constructor.reject(reason);\n    });\n  });\n};\n\nPromise.all = function (arr) {\n  return new Promise(function (resolve, reject) {\n    if (!arr || typeof arr.length === 'undefined') throw new TypeError('Promise.all accepts an array');\n    var args = Array.prototype.slice.call(arr);\n    if (args.length === 0) return resolve([]);\n    var remaining = args.length;\n\n    function res(i, val) {\n      try {\n        if (val && ((typeof val === 'undefined' ? 'undefined' : _typeof(val)) === 'object' || typeof val === 'function')) {\n          var then = val.then;\n          if (typeof then === 'function') {\n            then.call(val, function (val) {\n              res(i, val);\n            }, reject);\n            return;\n          }\n        }\n        args[i] = val;\n        if (--remaining === 0) {\n          resolve(args);\n        }\n      } catch (ex) {\n        reject(ex);\n      }\n    }\n\n    for (var i = 0; i < args.length; i++) {\n      res(i, args[i]);\n    }\n  });\n};\n\nPromise.resolve = function (value) {\n  if (value && (typeof value === 'undefined' ? 'undefined' : _typeof(value)) === 'object' && value.constructor === Promise) {\n    return value;\n  }\n\n  return new Promise(function (resolve) {\n    resolve(value);\n  });\n};\n\nPromise.reject = function (value) {\n  return new Promise(function (resolve, reject) {\n    reject(value);\n  });\n};\n\nPromise.race = function (values) {\n  return new Promise(function (resolve, reject) {\n    for (var i = 0, len = values.length; i < len; i++) {\n      values[i].then(resolve, reject);\n    }\n  });\n};\n\n// Use polyfill for setImmediate for performance gains\nPromise._immediateFn = typeof setImmediate === 'function' && function (fn) {\n  setImmediate(fn);\n} || function (fn) {\n  setTimeoutFunc(fn, 0);\n};\n\nPromise._unhandledRejectionFn = function _unhandledRejectionFn(err) {\n  if (typeof console !== 'undefined' && console) {\n    console.warn('Possible Unhandled Promise Rejection:', err); // eslint-disable-line no-console\n  }\n};\n\nexports.default = Promise;\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(9).setImmediate))\n\n/***/ }),\n/* 9 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/* WEBPACK VAR INJECTION */(function(global) {\n\nvar apply = Function.prototype.apply;\n\n// DOM APIs, for completeness\n\nexports.setTimeout = function () {\n  return new Timeout(apply.call(setTimeout, window, arguments), clearTimeout);\n};\nexports.setInterval = function () {\n  return new Timeout(apply.call(setInterval, window, arguments), clearInterval);\n};\nexports.clearTimeout = exports.clearInterval = function (timeout) {\n  if (timeout) {\n    timeout.close();\n  }\n};\n\nfunction Timeout(id, clearFn) {\n  this._id = id;\n  this._clearFn = clearFn;\n}\nTimeout.prototype.unref = Timeout.prototype.ref = function () {};\nTimeout.prototype.close = function () {\n  this._clearFn.call(window, this._id);\n};\n\n// Does not start the time, just sets up the members needed.\nexports.enroll = function (item, msecs) {\n  clearTimeout(item._idleTimeoutId);\n  item._idleTimeout = msecs;\n};\n\nexports.unenroll = function (item) {\n  clearTimeout(item._idleTimeoutId);\n  item._idleTimeout = -1;\n};\n\nexports._unrefActive = exports.active = function (item) {\n  clearTimeout(item._idleTimeoutId);\n\n  var msecs = item._idleTimeout;\n  if (msecs >= 0) {\n    item._idleTimeoutId = setTimeout(function onTimeout() {\n      if (item._onTimeout) item._onTimeout();\n    }, msecs);\n  }\n};\n\n// setimmediate attaches itself to the global object\n__webpack_require__(10);\n// On some exotic environments, it's not clear which object `setimmeidate` was\n// able to install onto.  Search each possibility in the same order as the\n// `setimmediate` library.\nexports.setImmediate = typeof self !== \"undefined\" && self.setImmediate || typeof global !== \"undefined\" && global.setImmediate || undefined && undefined.setImmediate;\nexports.clearImmediate = typeof self !== \"undefined\" && self.clearImmediate || typeof global !== \"undefined\" && global.clearImmediate || undefined && undefined.clearImmediate;\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(1)))\n\n/***/ }),\n/* 10 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/* WEBPACK VAR INJECTION */(function(global, process) {\n\n(function (global, undefined) {\n    \"use strict\";\n\n    if (global.setImmediate) {\n        return;\n    }\n\n    var nextHandle = 1; // Spec says greater than zero\n    var tasksByHandle = {};\n    var currentlyRunningATask = false;\n    var doc = global.document;\n    var registerImmediate;\n\n    function setImmediate(callback) {\n        // Callback can either be a function or a string\n        if (typeof callback !== \"function\") {\n            callback = new Function(\"\" + callback);\n        }\n        // Copy function arguments\n        var args = new Array(arguments.length - 1);\n        for (var i = 0; i < args.length; i++) {\n            args[i] = arguments[i + 1];\n        }\n        // Store and register the task\n        var task = { callback: callback, args: args };\n        tasksByHandle[nextHandle] = task;\n        registerImmediate(nextHandle);\n        return nextHandle++;\n    }\n\n    function clearImmediate(handle) {\n        delete tasksByHandle[handle];\n    }\n\n    function run(task) {\n        var callback = task.callback;\n        var args = task.args;\n        switch (args.length) {\n            case 0:\n                callback();\n                break;\n            case 1:\n                callback(args[0]);\n                break;\n            case 2:\n                callback(args[0], args[1]);\n                break;\n            case 3:\n                callback(args[0], args[1], args[2]);\n                break;\n            default:\n                callback.apply(undefined, args);\n                break;\n        }\n    }\n\n    function runIfPresent(handle) {\n        // From the spec: \"Wait until any invocations of this algorithm started before this one have completed.\"\n        // So if we're currently running a task, we'll need to delay this invocation.\n        if (currentlyRunningATask) {\n            // Delay by doing a setTimeout. setImmediate was tried instead, but in Firefox 7 it generated a\n            // \"too much recursion\" error.\n            setTimeout(runIfPresent, 0, handle);\n        } else {\n            var task = tasksByHandle[handle];\n            if (task) {\n                currentlyRunningATask = true;\n                try {\n                    run(task);\n                } finally {\n                    clearImmediate(handle);\n                    currentlyRunningATask = false;\n                }\n            }\n        }\n    }\n\n    function installNextTickImplementation() {\n        registerImmediate = function registerImmediate(handle) {\n            process.nextTick(function () {\n                runIfPresent(handle);\n            });\n        };\n    }\n\n    function canUsePostMessage() {\n        // The test against `importScripts` prevents this implementation from being installed inside a web worker,\n        // where `global.postMessage` means something completely different and can't be used for this purpose.\n        if (global.postMessage && !global.importScripts) {\n            var postMessageIsAsynchronous = true;\n            var oldOnMessage = global.onmessage;\n            global.onmessage = function () {\n                postMessageIsAsynchronous = false;\n            };\n            global.postMessage(\"\", \"*\");\n            global.onmessage = oldOnMessage;\n            return postMessageIsAsynchronous;\n        }\n    }\n\n    function installPostMessageImplementation() {\n        // Installs an event handler on `global` for the `message` event: see\n        // * https://developer.mozilla.org/en/DOM/window.postMessage\n        // * http://www.whatwg.org/specs/web-apps/current-work/multipage/comms.html#crossDocumentMessages\n\n        var messagePrefix = \"setImmediate$\" + Math.random() + \"$\";\n        var onGlobalMessage = function onGlobalMessage(event) {\n            if (event.source === global && typeof event.data === \"string\" && event.data.indexOf(messagePrefix) === 0) {\n                runIfPresent(+event.data.slice(messagePrefix.length));\n            }\n        };\n\n        if (global.addEventListener) {\n            global.addEventListener(\"message\", onGlobalMessage, false);\n        } else {\n            global.attachEvent(\"onmessage\", onGlobalMessage);\n        }\n\n        registerImmediate = function registerImmediate(handle) {\n            global.postMessage(messagePrefix + handle, \"*\");\n        };\n    }\n\n    function installMessageChannelImplementation() {\n        var channel = new MessageChannel();\n        channel.port1.onmessage = function (event) {\n            var handle = event.data;\n            runIfPresent(handle);\n        };\n\n        registerImmediate = function registerImmediate(handle) {\n            channel.port2.postMessage(handle);\n        };\n    }\n\n    function installReadyStateChangeImplementation() {\n        var html = doc.documentElement;\n        registerImmediate = function registerImmediate(handle) {\n            // Create a <script> element; its readystatechange event will be fired asynchronously once it is inserted\n            // into the document. Do so, thus queuing up the task. Remember to clean up once it's been called.\n            var script = doc.createElement(\"script\");\n            script.onreadystatechange = function () {\n                runIfPresent(handle);\n                script.onreadystatechange = null;\n                html.removeChild(script);\n                script = null;\n            };\n            html.appendChild(script);\n        };\n    }\n\n    function installSetTimeoutImplementation() {\n        registerImmediate = function registerImmediate(handle) {\n            setTimeout(runIfPresent, 0, handle);\n        };\n    }\n\n    // If supported, we should attach to the prototype of global, since that is where setTimeout et al. live.\n    var attachTo = Object.getPrototypeOf && Object.getPrototypeOf(global);\n    attachTo = attachTo && attachTo.setTimeout ? attachTo : global;\n\n    // Don't get fooled by e.g. browserify environments.\n    if ({}.toString.call(global.process) === \"[object process]\") {\n        // For Node.js before 0.9\n        installNextTickImplementation();\n    } else if (canUsePostMessage()) {\n        // For non-IE10 modern browsers\n        installPostMessageImplementation();\n    } else if (global.MessageChannel) {\n        // For web workers, where supported\n        installMessageChannelImplementation();\n    } else if (doc && \"onreadystatechange\" in doc.createElement(\"script\")) {\n        // For IE 6–8\n        installReadyStateChangeImplementation();\n    } else {\n        // For older browsers\n        installSetTimeoutImplementation();\n    }\n\n    attachTo.setImmediate = setImmediate;\n    attachTo.clearImmediate = clearImmediate;\n})(typeof self === \"undefined\" ? typeof global === \"undefined\" ? undefined : global : self);\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(1), __webpack_require__(11)))\n\n/***/ }),\n/* 11 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\n// shim for using process in browser\nvar process = module.exports = {};\n\n// cached from whatever global is present so that test runners that stub it\n// don't break things.  But we need to wrap it in a try catch in case it is\n// wrapped in strict mode code which doesn't define any globals.  It's inside a\n// function because try/catches deoptimize in certain engines.\n\nvar cachedSetTimeout;\nvar cachedClearTimeout;\n\nfunction defaultSetTimout() {\n    throw new Error('setTimeout has not been defined');\n}\nfunction defaultClearTimeout() {\n    throw new Error('clearTimeout has not been defined');\n}\n(function () {\n    try {\n        if (typeof setTimeout === 'function') {\n            cachedSetTimeout = setTimeout;\n        } else {\n            cachedSetTimeout = defaultSetTimout;\n        }\n    } catch (e) {\n        cachedSetTimeout = defaultSetTimout;\n    }\n    try {\n        if (typeof clearTimeout === 'function') {\n            cachedClearTimeout = clearTimeout;\n        } else {\n            cachedClearTimeout = defaultClearTimeout;\n        }\n    } catch (e) {\n        cachedClearTimeout = defaultClearTimeout;\n    }\n})();\nfunction runTimeout(fun) {\n    if (cachedSetTimeout === setTimeout) {\n        //normal enviroments in sane situations\n        return setTimeout(fun, 0);\n    }\n    // if setTimeout wasn't available but was latter defined\n    if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {\n        cachedSetTimeout = setTimeout;\n        return setTimeout(fun, 0);\n    }\n    try {\n        // when when somebody has screwed with setTimeout but no I.E. maddness\n        return cachedSetTimeout(fun, 0);\n    } catch (e) {\n        try {\n            // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally\n            return cachedSetTimeout.call(null, fun, 0);\n        } catch (e) {\n            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error\n            return cachedSetTimeout.call(this, fun, 0);\n        }\n    }\n}\nfunction runClearTimeout(marker) {\n    if (cachedClearTimeout === clearTimeout) {\n        //normal enviroments in sane situations\n        return clearTimeout(marker);\n    }\n    // if clearTimeout wasn't available but was latter defined\n    if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {\n        cachedClearTimeout = clearTimeout;\n        return clearTimeout(marker);\n    }\n    try {\n        // when when somebody has screwed with setTimeout but no I.E. maddness\n        return cachedClearTimeout(marker);\n    } catch (e) {\n        try {\n            // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally\n            return cachedClearTimeout.call(null, marker);\n        } catch (e) {\n            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.\n            // Some versions of I.E. have different rules for clearTimeout vs setTimeout\n            return cachedClearTimeout.call(this, marker);\n        }\n    }\n}\nvar queue = [];\nvar draining = false;\nvar currentQueue;\nvar queueIndex = -1;\n\nfunction cleanUpNextTick() {\n    if (!draining || !currentQueue) {\n        return;\n    }\n    draining = false;\n    if (currentQueue.length) {\n        queue = currentQueue.concat(queue);\n    } else {\n        queueIndex = -1;\n    }\n    if (queue.length) {\n        drainQueue();\n    }\n}\n\nfunction drainQueue() {\n    if (draining) {\n        return;\n    }\n    var timeout = runTimeout(cleanUpNextTick);\n    draining = true;\n\n    var len = queue.length;\n    while (len) {\n        currentQueue = queue;\n        queue = [];\n        while (++queueIndex < len) {\n            if (currentQueue) {\n                currentQueue[queueIndex].run();\n            }\n        }\n        queueIndex = -1;\n        len = queue.length;\n    }\n    currentQueue = null;\n    draining = false;\n    runClearTimeout(timeout);\n}\n\nprocess.nextTick = function (fun) {\n    var args = new Array(arguments.length - 1);\n    if (arguments.length > 1) {\n        for (var i = 1; i < arguments.length; i++) {\n            args[i - 1] = arguments[i];\n        }\n    }\n    queue.push(new Item(fun, args));\n    if (queue.length === 1 && !draining) {\n        runTimeout(drainQueue);\n    }\n};\n\n// v8 likes predictible objects\nfunction Item(fun, array) {\n    this.fun = fun;\n    this.array = array;\n}\nItem.prototype.run = function () {\n    this.fun.apply(null, this.array);\n};\nprocess.title = 'browser';\nprocess.browser = true;\nprocess.env = {};\nprocess.argv = [];\nprocess.version = ''; // empty string to avoid regexp issues\nprocess.versions = {};\n\nfunction noop() {}\n\nprocess.on = noop;\nprocess.addListener = noop;\nprocess.once = noop;\nprocess.off = noop;\nprocess.removeListener = noop;\nprocess.removeAllListeners = noop;\nprocess.emit = noop;\nprocess.prependListener = noop;\nprocess.prependOnceListener = noop;\n\nprocess.listeners = function (name) {\n    return [];\n};\n\nprocess.binding = function (name) {\n    throw new Error('process.binding is not supported');\n};\n\nprocess.cwd = function () {\n    return '/';\n};\nprocess.chdir = function (dir) {\n    throw new Error('process.chdir is not supported');\n};\nprocess.umask = function () {\n    return 0;\n};\n\n/***/ }),\n/* 12 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\n/**\n * Copyright 2016 Google Inc. All Rights Reserved.\n *\n * Licensed under the W3C SOFTWARE AND DOCUMENT NOTICE AND LICENSE.\n *\n *  https://www.w3.org/Consortium/Legal/2015/copyright-software-and-document\n *\n */\n\n(function (window, document) {\n  'use strict';\n\n  // Exits early if all IntersectionObserver and IntersectionObserverEntry\n  // features are natively supported.\n\n  if ('IntersectionObserver' in window && 'IntersectionObserverEntry' in window && 'intersectionRatio' in window.IntersectionObserverEntry.prototype) {\n\n    // Minimal polyfill for Edge 15's lack of `isIntersecting`\n    // See: https://github.com/w3c/IntersectionObserver/issues/211\n    if (!('isIntersecting' in window.IntersectionObserverEntry.prototype)) {\n      Object.defineProperty(window.IntersectionObserverEntry.prototype, 'isIntersecting', {\n        get: function get() {\n          return this.intersectionRatio > 0;\n        }\n      });\n    }\n    return;\n  }\n\n  /**\n   * An IntersectionObserver registry. This registry exists to hold a strong\n   * reference to IntersectionObserver instances currently observering a target\n   * element. Without this registry, instances without another reference may be\n   * garbage collected.\n   */\n  var registry = [];\n\n  /**\n   * Creates the global IntersectionObserverEntry constructor.\n   * https://w3c.github.io/IntersectionObserver/#intersection-observer-entry\n   * @param {Object} entry A dictionary of instance properties.\n   * @constructor\n   */\n  function IntersectionObserverEntry(entry) {\n    this.time = entry.time;\n    this.target = entry.target;\n    this.rootBounds = entry.rootBounds;\n    this.boundingClientRect = entry.boundingClientRect;\n    this.intersectionRect = entry.intersectionRect || getEmptyRect();\n    this.isIntersecting = !!entry.intersectionRect;\n\n    // Calculates the intersection ratio.\n    var targetRect = this.boundingClientRect;\n    var targetArea = targetRect.width * targetRect.height;\n    var intersectionRect = this.intersectionRect;\n    var intersectionArea = intersectionRect.width * intersectionRect.height;\n\n    // Sets intersection ratio.\n    if (targetArea) {\n      this.intersectionRatio = intersectionArea / targetArea;\n    } else {\n      // If area is zero and is intersecting, sets to 1, otherwise to 0\n      this.intersectionRatio = this.isIntersecting ? 1 : 0;\n    }\n  }\n\n  /**\n   * Creates the global IntersectionObserver constructor.\n   * https://w3c.github.io/IntersectionObserver/#intersection-observer-interface\n   * @param {Function} callback The function to be invoked after intersection\n   *     changes have queued. The function is not invoked if the queue has\n   *     been emptied by calling the `takeRecords` method.\n   * @param {Object=} opt_options Optional configuration options.\n   * @constructor\n   */\n  function IntersectionObserver(callback, opt_options) {\n\n    var options = opt_options || {};\n\n    if (typeof callback != 'function') {\n      throw new Error('callback must be a function');\n    }\n\n    if (options.root && options.root.nodeType != 1) {\n      throw new Error('root must be an Element');\n    }\n\n    // Binds and throttles `this._checkForIntersections`.\n    this._checkForIntersections = throttle(this._checkForIntersections.bind(this), this.THROTTLE_TIMEOUT);\n\n    // Private properties.\n    this._callback = callback;\n    this._observationTargets = [];\n    this._queuedEntries = [];\n    this._rootMarginValues = this._parseRootMargin(options.rootMargin);\n\n    // Public properties.\n    this.thresholds = this._initThresholds(options.threshold);\n    this.root = options.root || null;\n    this.rootMargin = this._rootMarginValues.map(function (margin) {\n      return margin.value + margin.unit;\n    }).join(' ');\n  }\n\n  /**\n   * The minimum interval within which the document will be checked for\n   * intersection changes.\n   */\n  IntersectionObserver.prototype.THROTTLE_TIMEOUT = 100;\n\n  /**\n   * The frequency in which the polyfill polls for intersection changes.\n   * this can be updated on a per instance basis and must be set prior to\n   * calling `observe` on the first target.\n   */\n  IntersectionObserver.prototype.POLL_INTERVAL = null;\n\n  /**\n   * Use a mutation observer on the root element\n   * to detect intersection changes.\n   */\n  IntersectionObserver.prototype.USE_MUTATION_OBSERVER = true;\n\n  /**\n   * Starts observing a target element for intersection changes based on\n   * the thresholds values.\n   * @param {Element} target The DOM element to observe.\n   */\n  IntersectionObserver.prototype.observe = function (target) {\n    var isTargetAlreadyObserved = this._observationTargets.some(function (item) {\n      return item.element == target;\n    });\n\n    if (isTargetAlreadyObserved) {\n      return;\n    }\n\n    if (!(target && target.nodeType == 1)) {\n      throw new Error('target must be an Element');\n    }\n\n    this._registerInstance();\n    this._observationTargets.push({ element: target, entry: null });\n    this._monitorIntersections();\n    this._checkForIntersections();\n  };\n\n  /**\n   * Stops observing a target element for intersection changes.\n   * @param {Element} target The DOM element to observe.\n   */\n  IntersectionObserver.prototype.unobserve = function (target) {\n    this._observationTargets = this._observationTargets.filter(function (item) {\n\n      return item.element != target;\n    });\n    if (!this._observationTargets.length) {\n      this._unmonitorIntersections();\n      this._unregisterInstance();\n    }\n  };\n\n  /**\n   * Stops observing all target elements for intersection changes.\n   */\n  IntersectionObserver.prototype.disconnect = function () {\n    this._observationTargets = [];\n    this._unmonitorIntersections();\n    this._unregisterInstance();\n  };\n\n  /**\n   * Returns any queue entries that have not yet been reported to the\n   * callback and clears the queue. This can be used in conjunction with the\n   * callback to obtain the absolute most up-to-date intersection information.\n   * @return {Array} The currently queued entries.\n   */\n  IntersectionObserver.prototype.takeRecords = function () {\n    var records = this._queuedEntries.slice();\n    this._queuedEntries = [];\n    return records;\n  };\n\n  /**\n   * Accepts the threshold value from the user configuration object and\n   * returns a sorted array of unique threshold values. If a value is not\n   * between 0 and 1 and error is thrown.\n   * @private\n   * @param {Array|number=} opt_threshold An optional threshold value or\n   *     a list of threshold values, defaulting to [0].\n   * @return {Array} A sorted list of unique and valid threshold values.\n   */\n  IntersectionObserver.prototype._initThresholds = function (opt_threshold) {\n    var threshold = opt_threshold || [0];\n    if (!Array.isArray(threshold)) threshold = [threshold];\n\n    return threshold.sort().filter(function (t, i, a) {\n      if (typeof t != 'number' || isNaN(t) || t < 0 || t > 1) {\n        throw new Error('threshold must be a number between 0 and 1 inclusively');\n      }\n      return t !== a[i - 1];\n    });\n  };\n\n  /**\n   * Accepts the rootMargin value from the user configuration object\n   * and returns an array of the four margin values as an object containing\n   * the value and unit properties. If any of the values are not properly\n   * formatted or use a unit other than px or %, and error is thrown.\n   * @private\n   * @param {string=} opt_rootMargin An optional rootMargin value,\n   *     defaulting to '0px'.\n   * @return {Array<Object>} An array of margin objects with the keys\n   *     value and unit.\n   */\n  IntersectionObserver.prototype._parseRootMargin = function (opt_rootMargin) {\n    var marginString = opt_rootMargin || '0px';\n    var margins = marginString.split(/\\s+/).map(function (margin) {\n      var parts = /^(-?\\d*\\.?\\d+)(px|%)$/.exec(margin);\n      if (!parts) {\n        throw new Error('rootMargin must be specified in pixels or percent');\n      }\n      return { value: parseFloat(parts[1]), unit: parts[2] };\n    });\n\n    // Handles shorthand.\n    margins[1] = margins[1] || margins[0];\n    margins[2] = margins[2] || margins[0];\n    margins[3] = margins[3] || margins[1];\n\n    return margins;\n  };\n\n  /**\n   * Starts polling for intersection changes if the polling is not already\n   * happening, and if the page's visibilty state is visible.\n   * @private\n   */\n  IntersectionObserver.prototype._monitorIntersections = function () {\n    if (!this._monitoringIntersections) {\n      this._monitoringIntersections = true;\n\n      // If a poll interval is set, use polling instead of listening to\n      // resize and scroll events or DOM mutations.\n      if (this.POLL_INTERVAL) {\n        this._monitoringInterval = setInterval(this._checkForIntersections, this.POLL_INTERVAL);\n      } else {\n        addEvent(window, 'resize', this._checkForIntersections, true);\n        addEvent(document, 'scroll', this._checkForIntersections, true);\n\n        if (this.USE_MUTATION_OBSERVER && 'MutationObserver' in window) {\n          this._domObserver = new MutationObserver(this._checkForIntersections);\n          this._domObserver.observe(document, {\n            attributes: true,\n            childList: true,\n            characterData: true,\n            subtree: true\n          });\n        }\n      }\n    }\n  };\n\n  /**\n   * Stops polling for intersection changes.\n   * @private\n   */\n  IntersectionObserver.prototype._unmonitorIntersections = function () {\n    if (this._monitoringIntersections) {\n      this._monitoringIntersections = false;\n\n      clearInterval(this._monitoringInterval);\n      this._monitoringInterval = null;\n\n      removeEvent(window, 'resize', this._checkForIntersections, true);\n      removeEvent(document, 'scroll', this._checkForIntersections, true);\n\n      if (this._domObserver) {\n        this._domObserver.disconnect();\n        this._domObserver = null;\n      }\n    }\n  };\n\n  /**\n   * Scans each observation target for intersection changes and adds them\n   * to the internal entries queue. If new entries are found, it\n   * schedules the callback to be invoked.\n   * @private\n   */\n  IntersectionObserver.prototype._checkForIntersections = function () {\n    var rootIsInDom = this._rootIsInDom();\n    var rootRect = rootIsInDom ? this._getRootRect() : getEmptyRect();\n\n    this._observationTargets.forEach(function (item) {\n      var target = item.element;\n      var targetRect = getBoundingClientRect(target);\n      var rootContainsTarget = this._rootContainsTarget(target);\n      var oldEntry = item.entry;\n      var intersectionRect = rootIsInDom && rootContainsTarget && this._computeTargetAndRootIntersection(target, rootRect);\n\n      var newEntry = item.entry = new IntersectionObserverEntry({\n        time: now(),\n        target: target,\n        boundingClientRect: targetRect,\n        rootBounds: rootRect,\n        intersectionRect: intersectionRect\n      });\n\n      if (!oldEntry) {\n        this._queuedEntries.push(newEntry);\n      } else if (rootIsInDom && rootContainsTarget) {\n        // If the new entry intersection ratio has crossed any of the\n        // thresholds, add a new entry.\n        if (this._hasCrossedThreshold(oldEntry, newEntry)) {\n          this._queuedEntries.push(newEntry);\n        }\n      } else {\n        // If the root is not in the DOM or target is not contained within\n        // root but the previous entry for this target had an intersection,\n        // add a new record indicating removal.\n        if (oldEntry && oldEntry.isIntersecting) {\n          this._queuedEntries.push(newEntry);\n        }\n      }\n    }, this);\n\n    if (this._queuedEntries.length) {\n      this._callback(this.takeRecords(), this);\n    }\n  };\n\n  /**\n   * Accepts a target and root rect computes the intersection between then\n   * following the algorithm in the spec.\n   * TODO(philipwalton): at this time clip-path is not considered.\n   * https://w3c.github.io/IntersectionObserver/#calculate-intersection-rect-algo\n   * @param {Element} target The target DOM element\n   * @param {Object} rootRect The bounding rect of the root after being\n   *     expanded by the rootMargin value.\n   * @return {?Object} The final intersection rect object or undefined if no\n   *     intersection is found.\n   * @private\n   */\n  IntersectionObserver.prototype._computeTargetAndRootIntersection = function (target, rootRect) {\n\n    // If the element isn't displayed, an intersection can't happen.\n    if (window.getComputedStyle(target).display == 'none') return;\n\n    var targetRect = getBoundingClientRect(target);\n    var intersectionRect = targetRect;\n    var parent = getParentNode(target);\n    var atRoot = false;\n\n    while (!atRoot) {\n      var parentRect = null;\n      var parentComputedStyle = parent.nodeType == 1 ? window.getComputedStyle(parent) : {};\n\n      // If the parent isn't displayed, an intersection can't happen.\n      if (parentComputedStyle.display == 'none') return;\n\n      if (parent == this.root || parent == document) {\n        atRoot = true;\n        parentRect = rootRect;\n      } else {\n        // If the element has a non-visible overflow, and it's not the <body>\n        // or <html> element, update the intersection rect.\n        // Note: <body> and <html> cannot be clipped to a rect that's not also\n        // the document rect, so no need to compute a new intersection.\n        if (parent != document.body && parent != document.documentElement && parentComputedStyle.overflow != 'visible') {\n          parentRect = getBoundingClientRect(parent);\n        }\n      }\n\n      // If either of the above conditionals set a new parentRect,\n      // calculate new intersection data.\n      if (parentRect) {\n        intersectionRect = computeRectIntersection(parentRect, intersectionRect);\n\n        if (!intersectionRect) break;\n      }\n      parent = getParentNode(parent);\n    }\n    return intersectionRect;\n  };\n\n  /**\n   * Returns the root rect after being expanded by the rootMargin value.\n   * @return {Object} The expanded root rect.\n   * @private\n   */\n  IntersectionObserver.prototype._getRootRect = function () {\n    var rootRect;\n    if (this.root) {\n      rootRect = getBoundingClientRect(this.root);\n    } else {\n      // Use <html>/<body> instead of window since scroll bars affect size.\n      var html = document.documentElement;\n      var body = document.body;\n      rootRect = {\n        top: 0,\n        left: 0,\n        right: html.clientWidth || body.clientWidth,\n        width: html.clientWidth || body.clientWidth,\n        bottom: html.clientHeight || body.clientHeight,\n        height: html.clientHeight || body.clientHeight\n      };\n    }\n    return this._expandRectByRootMargin(rootRect);\n  };\n\n  /**\n   * Accepts a rect and expands it by the rootMargin value.\n   * @param {Object} rect The rect object to expand.\n   * @return {Object} The expanded rect.\n   * @private\n   */\n  IntersectionObserver.prototype._expandRectByRootMargin = function (rect) {\n    var margins = this._rootMarginValues.map(function (margin, i) {\n      return margin.unit == 'px' ? margin.value : margin.value * (i % 2 ? rect.width : rect.height) / 100;\n    });\n    var newRect = {\n      top: rect.top - margins[0],\n      right: rect.right + margins[1],\n      bottom: rect.bottom + margins[2],\n      left: rect.left - margins[3]\n    };\n    newRect.width = newRect.right - newRect.left;\n    newRect.height = newRect.bottom - newRect.top;\n\n    return newRect;\n  };\n\n  /**\n   * Accepts an old and new entry and returns true if at least one of the\n   * threshold values has been crossed.\n   * @param {?IntersectionObserverEntry} oldEntry The previous entry for a\n   *    particular target element or null if no previous entry exists.\n   * @param {IntersectionObserverEntry} newEntry The current entry for a\n   *    particular target element.\n   * @return {boolean} Returns true if a any threshold has been crossed.\n   * @private\n   */\n  IntersectionObserver.prototype._hasCrossedThreshold = function (oldEntry, newEntry) {\n\n    // To make comparing easier, an entry that has a ratio of 0\n    // but does not actually intersect is given a value of -1\n    var oldRatio = oldEntry && oldEntry.isIntersecting ? oldEntry.intersectionRatio || 0 : -1;\n    var newRatio = newEntry.isIntersecting ? newEntry.intersectionRatio || 0 : -1;\n\n    // Ignore unchanged ratios\n    if (oldRatio === newRatio) return;\n\n    for (var i = 0; i < this.thresholds.length; i++) {\n      var threshold = this.thresholds[i];\n\n      // Return true if an entry matches a threshold or if the new ratio\n      // and the old ratio are on the opposite sides of a threshold.\n      if (threshold == oldRatio || threshold == newRatio || threshold < oldRatio !== threshold < newRatio) {\n        return true;\n      }\n    }\n  };\n\n  /**\n   * Returns whether or not the root element is an element and is in the DOM.\n   * @return {boolean} True if the root element is an element and is in the DOM.\n   * @private\n   */\n  IntersectionObserver.prototype._rootIsInDom = function () {\n    return !this.root || containsDeep(document, this.root);\n  };\n\n  /**\n   * Returns whether or not the target element is a child of root.\n   * @param {Element} target The target element to check.\n   * @return {boolean} True if the target element is a child of root.\n   * @private\n   */\n  IntersectionObserver.prototype._rootContainsTarget = function (target) {\n    return containsDeep(this.root || document, target);\n  };\n\n  /**\n   * Adds the instance to the global IntersectionObserver registry if it isn't\n   * already present.\n   * @private\n   */\n  IntersectionObserver.prototype._registerInstance = function () {\n    if (registry.indexOf(this) < 0) {\n      registry.push(this);\n    }\n  };\n\n  /**\n   * Removes the instance from the global IntersectionObserver registry.\n   * @private\n   */\n  IntersectionObserver.prototype._unregisterInstance = function () {\n    var index = registry.indexOf(this);\n    if (index != -1) registry.splice(index, 1);\n  };\n\n  /**\n   * Returns the result of the performance.now() method or null in browsers\n   * that don't support the API.\n   * @return {number} The elapsed time since the page was requested.\n   */\n  function now() {\n    return window.performance && performance.now && performance.now();\n  }\n\n  /**\n   * Throttles a function and delays its executiong, so it's only called at most\n   * once within a given time period.\n   * @param {Function} fn The function to throttle.\n   * @param {number} timeout The amount of time that must pass before the\n   *     function can be called again.\n   * @return {Function} The throttled function.\n   */\n  function throttle(fn, timeout) {\n    var timer = null;\n    return function () {\n      if (!timer) {\n        timer = setTimeout(function () {\n          fn();\n          timer = null;\n        }, timeout);\n      }\n    };\n  }\n\n  /**\n   * Adds an event handler to a DOM node ensuring cross-browser compatibility.\n   * @param {Node} node The DOM node to add the event handler to.\n   * @param {string} event The event name.\n   * @param {Function} fn The event handler to add.\n   * @param {boolean} opt_useCapture Optionally adds the even to the capture\n   *     phase. Note: this only works in modern browsers.\n   */\n  function addEvent(node, event, fn, opt_useCapture) {\n    if (typeof node.addEventListener == 'function') {\n      node.addEventListener(event, fn, opt_useCapture || false);\n    } else if (typeof node.attachEvent == 'function') {\n      node.attachEvent('on' + event, fn);\n    }\n  }\n\n  /**\n   * Removes a previously added event handler from a DOM node.\n   * @param {Node} node The DOM node to remove the event handler from.\n   * @param {string} event The event name.\n   * @param {Function} fn The event handler to remove.\n   * @param {boolean} opt_useCapture If the event handler was added with this\n   *     flag set to true, it should be set to true here in order to remove it.\n   */\n  function removeEvent(node, event, fn, opt_useCapture) {\n    if (typeof node.removeEventListener == 'function') {\n      node.removeEventListener(event, fn, opt_useCapture || false);\n    } else if (typeof node.detatchEvent == 'function') {\n      node.detatchEvent('on' + event, fn);\n    }\n  }\n\n  /**\n   * Returns the intersection between two rect objects.\n   * @param {Object} rect1 The first rect.\n   * @param {Object} rect2 The second rect.\n   * @return {?Object} The intersection rect or undefined if no intersection\n   *     is found.\n   */\n  function computeRectIntersection(rect1, rect2) {\n    var top = Math.max(rect1.top, rect2.top);\n    var bottom = Math.min(rect1.bottom, rect2.bottom);\n    var left = Math.max(rect1.left, rect2.left);\n    var right = Math.min(rect1.right, rect2.right);\n    var width = right - left;\n    var height = bottom - top;\n\n    return width >= 0 && height >= 0 && {\n      top: top,\n      bottom: bottom,\n      left: left,\n      right: right,\n      width: width,\n      height: height\n    };\n  }\n\n  /**\n   * Shims the native getBoundingClientRect for compatibility with older IE.\n   * @param {Element} el The element whose bounding rect to get.\n   * @return {Object} The (possibly shimmed) rect of the element.\n   */\n  function getBoundingClientRect(el) {\n    var rect;\n\n    try {\n      rect = el.getBoundingClientRect();\n    } catch (err) {\n      // Ignore Windows 7 IE11 \"Unspecified error\"\n      // https://github.com/w3c/IntersectionObserver/pull/205\n    }\n\n    if (!rect) return getEmptyRect();\n\n    // Older IE\n    if (!(rect.width && rect.height)) {\n      rect = {\n        top: rect.top,\n        right: rect.right,\n        bottom: rect.bottom,\n        left: rect.left,\n        width: rect.right - rect.left,\n        height: rect.bottom - rect.top\n      };\n    }\n    return rect;\n  }\n\n  /**\n   * Returns an empty rect object. An empty rect is returned when an element\n   * is not in the DOM.\n   * @return {Object} The empty rect.\n   */\n  function getEmptyRect() {\n    return {\n      top: 0,\n      bottom: 0,\n      left: 0,\n      right: 0,\n      width: 0,\n      height: 0\n    };\n  }\n\n  /**\n   * Checks to see if a parent element contains a child elemnt (including inside\n   * shadow DOM).\n   * @param {Node} parent The parent element.\n   * @param {Node} child The child element.\n   * @return {boolean} True if the parent node contains the child node.\n   */\n  function containsDeep(parent, child) {\n    var node = child;\n    while (node) {\n      if (node == parent) return true;\n\n      node = getParentNode(node);\n    }\n    return false;\n  }\n\n  /**\n   * Gets the parent node of an element or its host element if the parent node\n   * is a shadow root.\n   * @param {Node} node The node whose parent to get.\n   * @return {Node|null} The parent node or null if no parent exists.\n   */\n  function getParentNode(node) {\n    var parent = node.parentNode;\n\n    if (parent && parent.nodeType == 11 && parent.host) {\n      // If the parent is a shadow root, return the host element.\n      return parent.host;\n    }\n    return parent;\n  }\n\n  // Exposes the constructors globally.\n  window.IntersectionObserver = IntersectionObserver;\n  window.IntersectionObserverEntry = IntersectionObserverEntry;\n})(window, document);\n\n/***/ }),\n/* 13 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar _domready = __webpack_require__(14);\n\nvar _domready2 = _interopRequireDefault(_domready);\n\nvar _preact = __webpack_require__(0);\n\nvar _nodelistToArray = __webpack_require__(15);\n\nvar _uuid = __webpack_require__(16);\n\nvar _errorReporting = __webpack_require__(17);\n\nvar _provider = __webpack_require__(3);\n\nvar _App = __webpack_require__(19);\n\nvar _App2 = __webpack_require__(4);\n\nvar _dhAnalyticsUtils = __webpack_require__(35);\n\nvar _getContextId = __webpack_require__(36);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\n/* global __HOT__ */\n/** @jsx h */\nwindow[_App2.root] = window[_App2.root] || {};\n\nfunction init() {\n  findElements().forEach(function (el) {\n    el.id = (0, _uuid.uuid)();\n    window[_App2.root][el.id] = true;\n\n    // Extract preloaded state sent from server\n    var preloadedState = JSON.parse(el.getAttribute('data-preloaded-state'));\n    var errorEventTrackingEnabled = preloadedState.errorEventTrackingEnabled;\n\n    var simpleErrorReport = (0, _errorReporting.createErrorReporter)(errorEventTrackingEnabled);\n    simpleErrorReport.listenAndCatch();\n\n    // Extract metadata required to create google analytics tracker\n    var gaPropertyId = el.getAttribute('data-ga-property-id');\n    var metadata = JSON.parse(el.getAttribute('data-metadata'));\n    var title = metadata.title,\n        selfId = metadata.selfId,\n        published = metadata.published;\n\n    // create google analytics tracker\n\n    var googleAnalyticsTracker = (0, _dhAnalyticsUtils.createGoogleAnalyticsTracker)({\n      name: 'dh',\n      gaPropertyId: gaPropertyId,\n      self: {\n        id: selfId,\n        title: title,\n        publishedDate: published ? new Date(published) : null\n      },\n      context: {\n        id: (0, _getContextId.getContextId)(document.location.href)\n      }\n    });\n\n    var sendErrorReport = function sendErrorReport(message) {\n      simpleErrorReport.sendErrorReport({ message: message });\n    };\n\n    var trackAction = function trackAction(action, value) {\n      var eventObj = {\n        category: 'spesialmodul',\n        action: action,\n        label: 'dh-plastic-counter'\n      };\n      if (value) {\n        eventObj.value = value;\n      }\n      googleAnalyticsTracker.sendEvent(eventObj);\n    };\n\n    // ... and render with the exact same props\n    (0, _preact.render)((0, _preact.h)(\n      _provider.Provider,\n      { sendErrorReport: sendErrorReport, trackAction: trackAction },\n      (0, _preact.h)(_App.App, preloadedState)\n    ), el, el.firstChild);\n\n    // Enable webpack hot-reloading\n    if (false) {\n      // Reload and re-render React application\n      require('preact/debug');\n      module.hot.accept('./client', function () {\n        (0, _preact.render)(require('./components/App').default, el, el.firstChild);\n      });\n    }\n  });\n}\n\nfunction findElements() {\n  return (0, _nodelistToArray.nodelistToArray)(document.getElementsByClassName(_App2.root)).filter(function (el) {\n    return !isInitialized(el);\n  });\n}\n\nfunction isInitialized(el) {\n  return el.id && window[_App2.root][el.id];\n}\n\n(0, _domready2.default)(init);\n\n/***/ }),\n/* 14 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar _typeof = typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; };\n\n/*!\n  * domready (c) Dustin Diaz 2014 - License MIT\n  */\n!function (name, definition) {\n\n  if (true) module.exports = definition();else if (typeof define == 'function' && _typeof(define.amd) == 'object') define(definition);else this[name] = definition();\n}('domready', function () {\n\n  var fns = [],\n      _listener,\n      doc = document,\n      hack = doc.documentElement.doScroll,\n      domContentLoaded = 'DOMContentLoaded',\n      loaded = (hack ? /^loaded|^c/ : /^loaded|^i|^c/).test(doc.readyState);\n\n  if (!loaded) doc.addEventListener(domContentLoaded, _listener = function listener() {\n    doc.removeEventListener(domContentLoaded, _listener);\n    loaded = 1;\n    while (_listener = fns.shift()) {\n      _listener();\n    }\n  });\n\n  return function (fn) {\n    loaded ? setTimeout(fn, 0) : fns.push(fn);\n  };\n});\n\n/***/ }),\n/* 15 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.nodelistToArray = nodelistToArray;\nfunction nodelistToArray(nodeList) {\n  return [].slice.call(nodeList);\n}\n\n/***/ }),\n/* 16 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.uuid = uuid;\nfunction uuid() {\n  return \"_\" + Math.random().toString(36).substr(2, 9);\n}\n\n/***/ }),\n/* 17 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.createErrorReporter = createErrorReporter;\n\nvar _dhSimpleErrorReport = __webpack_require__(18);\n\nfunction createErrorReporter(isErrorReportingEnabled) {\n  return new _dhSimpleErrorReport.SimpleErrorReport({\n    name: 'dh-plastic-counter',\n    url: 'https://dh.nrk.no/catch',\n    dryRun: !isErrorReportingEnabled\n  });\n}\n\n/***/ }),\n/* 18 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\nvar __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;\n\nvar _typeof = typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; };\n\n!function (e, n) {\n  \"object\" == ( false ? \"undefined\" : _typeof(exports)) && \"undefined\" != typeof module ? n(exports) :  true ? !(__WEBPACK_AMD_DEFINE_ARRAY__ = [exports], __WEBPACK_AMD_DEFINE_FACTORY__ = (n),\n\t\t\t\t__WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ?\n\t\t\t\t(__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__),\n\t\t\t\t__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)) : n(e[\"simple-error-report\"] = {});\n}(undefined, function (e) {\n  \"use strict\";\n  var n = function () {\n    function e(e, n) {\n      for (var r = 0; r < n.length; r++) {\n        var t = n[r];t.enumerable = t.enumerable || !1, t.configurable = !0, \"value\" in t && (t.writable = !0), Object.defineProperty(e, t.key, t);\n      }\n    }return function (n, r, t) {\n      return r && e(n.prototype, r), t && e(n, t), n;\n    };\n  }();var r = function () {\n    function e() {\n      !function (e, n) {\n        if (!(e instanceof n)) throw new TypeError(\"Cannot call a class as a function\");\n      }(this, e), this.register = [];\n    }return n(e, [{ key: \"addErrorToRegister\", value: function value(e) {\n        this.register.push({ time: new Date(), message: e });\n      } }, { key: \"isInRegisterWithinRange\", value: function value(e, n) {\n        return this.register.filter(function (r) {\n          return r.message === e && new Date() - r.time < n;\n        }).length > 0;\n      } }]), e;\n  }(),\n      t = function () {\n    function e(e, n) {\n      for (var r = 0; r < n.length; r++) {\n        var t = n[r];t.enumerable = t.enumerable || !1, t.configurable = !0, \"value\" in t && (t.writable = !0), Object.defineProperty(e, t.key, t);\n      }\n    }return function (n, r, t) {\n      return r && e(n.prototype, r), t && e(n, t), n;\n    };\n  }();var i = [],\n      o = function () {\n    function e(n) {\n      var t = n.name,\n          o = n.url,\n          s = n.dryRun,\n          a = void 0 === s || s;!function (e, n) {\n        if (!(e instanceof n)) throw new TypeError(\"Cannot call a class as a function\");\n      }(this, e), this.name = t, this.url = o, this.errorRegister = new r(), this.dryRun = a, i.push(this.name);\n    }return t(e, [{ key: \"listenAndCatch\", value: function value() {\n        var e = this;i.length <= 1 && (window.addEventListener(\"error\", function (n) {\n          var r = n.message,\n              t = n.filename,\n              i = n.lineno,\n              o = n.colno,\n              s = { message: r };\"\" !== t && (s.url = t), i > 0 && (s.line = i), o > 0 && (s.column = o), e.sendErrorReport(s);\n        }), window.addEventListener(\"unhandledrejection\", function (n) {\n          e.sendErrorReport({ message: \"Unhandled Promise Rejection: \" + n.reason });\n        }));\n      } }, { key: \"sendErrorReport\", value: function value(e) {\n        var n, r, t;this.dryRun ? \"undefined\" != typeof console && console.log(\"Dry run: \" + JSON.stringify(e)) : this.errorRegister.isInRegisterWithinRange(e.message, 500) || (this.errorRegister.addErrorToRegister(e.message), n = this.url + \"/\" + this.name, r = e, (t = new XMLHttpRequest()).open(\"POST\", n), t.setRequestHeader(\"Content-Type\", \"application/json\"), t.send(JSON.stringify(r)));\n      } }]), e;\n  }();e.SimpleErrorReport = o, Object.defineProperty(e, \"__esModule\", { value: !0 });\n});\n\n/***/ }),\n/* 19 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.App = undefined;\n\nvar _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();\n\nvar _preact = __webpack_require__(0);\n\nvar _provider = __webpack_require__(3);\n\nvar _App = __webpack_require__(4);\n\nvar _App2 = _interopRequireDefault(_App);\n\nvar _debounce = __webpack_require__(20);\n\nvar _bem = __webpack_require__(2);\n\nvar _InfoBox = __webpack_require__(21);\n\nvar _Trash = __webpack_require__(25);\n\nvar _Sea = __webpack_require__(29);\n\nvar _SeaOverlay = __webpack_require__(31);\n\nvar _SeaLight = __webpack_require__(33);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return call && (typeof call === \"object\" || typeof call === \"function\") ? call : self; }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function, not \" + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } //  @jsx h\n\nvar PLASTIC_IN_KILO_PER_SECOND = 250;\nvar MAX_FPS_COUNT = 3;\nvar trackFpsCount = 0;\n\nvar AppComponent = function (_Component) {\n  _inherits(AppComponent, _Component);\n\n  function AppComponent() {\n    var _ref;\n\n    var _temp, _this, _ret;\n\n    _classCallCheck(this, AppComponent);\n\n    for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {\n      args[_key] = arguments[_key];\n    }\n\n    return _ret = (_temp = (_this = _possibleConstructorReturn(this, (_ref = AppComponent.__proto__ || Object.getPrototypeOf(AppComponent)).call.apply(_ref, [this].concat(args))), _this), _this.state = {\n      amount: 0,\n      hasIntersected: false,\n      prefersReducedMotion: false,\n      speedModifier: 2.5,\n      breakpoint: 'small',\n      width: 0,\n      height: 0\n    }, _this.interval = null, _this.observer = null, _this.debouncedResize = null, _this.rootEl = null, _this.overrideXlStyles = function () {\n      var allContainers = [].concat(_toConsumableArray(document.querySelectorAll('.remoterenderedcontent-reference')));\n\n      var container = allContainers.filter(function (c) {\n        return c.querySelector('.' + _App2.default.app);\n      })[0];\n\n      if (container) {\n        container.style.padding = '0';\n      }\n\n      if (_this.rootEl) {\n        _this.setState({\n          width: _this.rootEl.offsetWidth,\n          height: _this.rootEl.offsetHeight\n        });\n      }\n    }, _this.handleReducedMotion = function () {\n      var trackAction = _this.props.trackAction;\n\n      var _window$matchMedia = window.matchMedia('(prefers-reduced-motion: reduce)'),\n          prefersReducedMotion = _window$matchMedia.matches;\n\n      _this.setState({ prefersReducedMotion: prefersReducedMotion });\n      if (prefersReducedMotion) {\n        _this.setState({ speedModifier: 0.5 });\n        trackAction('PREFER_REDUCED_MOTION');\n      }\n    }, _this.handleFpsUpdate = function (fps) {\n      var trackAction = _this.props.trackAction;\n\n      if (trackFpsCount <= MAX_FPS_COUNT) {\n        if (fps <= 61) {\n          trackAction('FPS', fps);\n          trackFpsCount++;\n        }\n      }\n    }, _this.handleObserve = function (enteries, observer) {\n      var _ref2 = enteries && enteries[0] || false,\n          isIntersecting = _ref2.isIntersecting;\n\n      var hasIntersected = _this.state.hasIntersected;\n      var trackAction = _this.props.trackAction;\n\n\n      if (isIntersecting && !hasIntersected) {\n        _this.setState({ hasIntersected: true });\n        trackAction('SCROLL_IN');\n      } else if (hasIntersected) {\n        trackAction(isIntersecting ? 'SCROLL_IN' : 'SCROLL_OUT');\n      }\n    }, _this.handleResize = function () {\n      if (!_this.rootEl) return;\n      _this.setState({ breakpoint: getCurrentBreakpoint(_this.rootEl.offsetWidth) });\n    }, _temp), _possibleConstructorReturn(_this, _ret);\n  } // IntervalID\n\n\n  _createClass(AppComponent, [{\n    key: 'componentDidMount',\n    value: function componentDidMount() {\n      var _this2 = this;\n\n      this.handleResize();\n      this.debouncedResize = (0, _debounce.debounce)(this.handleResize, 16.667);\n      window.addEventListener('resize', this.debouncedResize);\n\n      this.handleReducedMotion();\n\n      this.observer = new IntersectionObserver(this.handleObserve, {});\n      var rootEl = this.rootEl;\n\n      if (rootEl) {\n        this.setState({ width: rootEl.offsetWidth, height: rootEl.offsetHeight });\n        this.observer.observe(rootEl);\n      }\n\n      this.interval = setInterval(function () {\n        var amount = _this2.state.amount;\n\n        _this2.setState({\n          amount: amount + PLASTIC_IN_KILO_PER_SECOND / _this2.state.speedModifier\n        });\n      }, 1000 / this.state.speedModifier);\n\n      if (this.props.isXl) {\n        this.overrideXlStyles();\n      }\n    }\n  }, {\n    key: 'componentWillUnmount',\n    value: function componentWillUnmount() {\n      window.removeEventListener('resize', this.debouncedResize);\n      if (this.interval) {\n        clearInterval(this.interval);\n      }\n      if (this.observer) {\n        this.observer.disconnect();\n        this.observer = null;\n      }\n    }\n  }, {\n    key: 'render',\n    value: function render() {\n      var _this3 = this;\n\n      var _props = this.props,\n          href = _props.href,\n          showLink = _props.showLink,\n          linkText = _props.linkText;\n      var _state = this.state,\n          amount = _state.amount,\n          hasIntersected = _state.hasIntersected,\n          breakpoint = _state.breakpoint,\n          height = _state.height,\n          width = _state.width,\n          prefersReducedMotion = _state.prefersReducedMotion;\n\n      return (0, _preact.h)(\n        'div',\n        {\n          'class': (0, _bem.bem)(_App2.default.app, breakpoint, hasIntersected && 'has-intersected'),\n          ref: function ref(el) {\n            _this3.rootEl = el;\n          }\n        },\n        (0, _preact.h)(_Sea.Sea, null),\n        (0, _preact.h)(_Trash.Trash, {\n          prefersReducedMotion: prefersReducedMotion,\n          shouldMount: hasIntersected,\n          height: height,\n          width: width,\n          onFpsUpdate: this.handleFpsUpdate\n        }),\n        (0, _preact.h)(_SeaLight.SeaLight, null),\n        (0, _preact.h)(_SeaOverlay.SeaOverlay, null),\n        (0, _preact.h)(_InfoBox.InfoBox, {\n          amount: amount,\n          showLink: showLink,\n          href: href,\n          linkText: linkText\n        })\n      );\n    }\n  }]);\n\n  return AppComponent;\n}(_preact.Component);\n\nvar App = (0, _provider.connect)()(AppComponent);\n\nexports.App = App;\n\n\nfunction getCurrentBreakpoint(width) {\n  if (width > 1600) return 'extra-large';\n  if (width > 1200) return 'large';\n  if (width > 800) return 'medium';\n  return 'small';\n}\n\n/***/ }),\n/* 20 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nfunction debounce(func, wait, immediate) {\n  var timeout = void 0;\n\n  return function () {\n    var context = this;\n    var args = arguments;\n\n    var later = function later() {\n      timeout = null;\n      if (!immediate) func.apply(context, args);\n    };\n    var callNow = immediate && !timeout;\n    if (timeout) clearTimeout(timeout);\n    timeout = setTimeout(later, wait);\n    if (callNow) func.apply(context, args);\n  };\n}\n\nexports.debounce = debounce;\n\n/***/ }),\n/* 21 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.InfoBox = undefined;\n\nvar _preact = __webpack_require__(0);\n\nvar _Counter = __webpack_require__(22);\n\nvar _bem = __webpack_require__(2);\n\nvar _InfoBox = __webpack_require__(24);\n\nvar _InfoBox2 = _interopRequireDefault(_InfoBox);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\n//  @jsx h\nvar InfoBox = exports.InfoBox = function InfoBox(_ref) {\n  var amount = _ref.amount,\n      showLink = _ref.showLink,\n      href = _ref.href,\n      linkText = _ref.linkText;\n\n  var amountInBottles = Math.ceil(amount * 20).toLocaleString('no');\n  var amountInFleece = Math.ceil(amount * 33).toLocaleString('no');\n\n  return (0, _preact.h)(\n    'div',\n    { 'class': _InfoBox2.default['info-box'] },\n    (0, _preact.h)(\n      'div',\n      { 'class': _InfoBox2.default['info-box__inner'] },\n      (0, _preact.h)(\n        'span',\n        { 'class': 'nrk-sr' },\n        'Mens du har lest denne artikkelen har det havnet',\n        ' ',\n        parseFloat(amount / 1000).toFixed(1),\n        ' tonn plast i havet. Det tilsvarer ',\n        amountInBottles,\n        ' flasker eller ',\n        amountInFleece,\n        ' bleier.'\n      ),\n      (0, _preact.h)(\n        'p',\n        { 'class': _InfoBox2.default['info-box__paragraph'], 'aria-hidden': true },\n        (0, _preact.h)(\n          'span',\n          { 'class': _InfoBox2.default['info-box__text-line'] },\n          'Mens du har lest denne artikkelen'\n        ),\n        ' ',\n        (0, _preact.h)(\n          'span',\n          { 'class': _InfoBox2.default['info-box__text-line'] },\n          'har det havnet'\n        ),\n        (0, _preact.h)(_Counter.Counter, {\n          amount: parseFloat(amount / 1000).toFixed(1),\n          afterText: ' tonn'\n        }),\n        (0, _preact.h)(\n          'span',\n          { 'class': _InfoBox2.default['info-box__big-text'] },\n          'plast i havet'\n        )\n      ),\n      (0, _preact.h)(\n        'p',\n        { 'class': (0, _bem.bem)(_InfoBox2.default['info-box__paragraph'], 'darker'), 'aria-hidden': true },\n        (0, _preact.h)(\n          'span',\n          { 'class': _InfoBox2.default['info-box__text-line'] },\n          'Det tilsvarer ',\n          amountInBottles,\n          ' flasker',\n          ' '\n        ),\n        (0, _preact.h)(\n          'span',\n          { 'class': _InfoBox2.default['info-box__text-line'] },\n          'eller ',\n          amountInFleece,\n          ' bleier.'\n        )\n      ),\n      showLink && href && (0, _preact.h)(\n        'a',\n        {\n          'class': 'nrk-button ' + _InfoBox2.default['info-box__link-button'],\n          href: href\n        },\n        linkText || 'Hva kan jeg gjøre med det?',\n        (0, _preact.h)(\n          'span',\n          { 'aria-hidden': true },\n          (0, _preact.h)(\n            'svg',\n            {\n              xmlns: 'http://www.w3.org/2000/svg',\n              viewBox: '0 0 26 15',\n              width: '25'\n            },\n            (0, _preact.h)('path', {\n              stroke: 'currentColor',\n              fill: 'none',\n              strokeLinecap: 'round',\n              d: 'M2 7.5h22m-6-6l6 6-6 6'\n            })\n          )\n        )\n      )\n    )\n  );\n};\n\n/***/ }),\n/* 22 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.Counter = undefined;\n\nvar _preact = __webpack_require__(0);\n\nvar _Counter = __webpack_require__(23);\n\nvar _Counter2 = _interopRequireDefault(_Counter);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\n//  @jsx h\n\nvar Counter = exports.Counter = function Counter(_ref) {\n  var amount = _ref.amount,\n      afterText = _ref.afterText;\n\n  var amountInTon = String(amount).replace('.', ',');\n  return (0, _preact.h)(\n    'span',\n    { className: _Counter2.default.counter },\n    amountInTon.split('').map(function (v, i) {\n      return (0, _preact.h)(\n        'span',\n        { 'class': v === ',' ? '' : _Counter2.default.counter__number, key: v + '' + i },\n        v\n      );\n    }),\n    afterText\n  );\n};\n\n/***/ }),\n/* 23 */\n/***/ (function(module, exports) {\n\n// removed by extract-text-webpack-plugin\nmodule.exports = {\"counter\":\"dh-dh-plastic-counter-counter\",\"app--small\":\"dh-dh-plastic-counter-app--small\",\"counter__number\":\"dh-dh-plastic-counter-counter__number\"};\n\n/***/ }),\n/* 24 */\n/***/ (function(module, exports) {\n\n// removed by extract-text-webpack-plugin\nmodule.exports = {\"info-box\":\"dh-dh-plastic-counter-info-box\",\"info-box__inner\":\"dh-dh-plastic-counter-info-box__inner\",\"info-box__paragraph\":\"dh-dh-plastic-counter-info-box__paragraph\",\"info-box__paragraph--darker\":\"dh-dh-plastic-counter-info-box__paragraph--darker\",\"info-box__link-button\":\"dh-dh-plastic-counter-info-box__link-button\",\"info-box__big-text\":\"dh-dh-plastic-counter-info-box__big-text\",\"app--small\":\"dh-dh-plastic-counter-app--small\",\"info-box__text-line\":\"dh-dh-plastic-counter-info-box__text-line\"};\n\n/***/ }),\n/* 25 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.Trash = undefined;\n\nvar _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();\n\nvar _preact = __webpack_require__(0);\n\nvar _trashController = __webpack_require__(26);\n\nvar _bem = __webpack_require__(2);\n\nvar _Trash = __webpack_require__(28);\n\nvar _Trash2 = _interopRequireDefault(_Trash);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return call && (typeof call === \"object\" || typeof call === \"function\") ? call : self; }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function, not \" + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } //  @jsx h\n\nvar Trash = exports.Trash = function (_Component) {\n  _inherits(Trash, _Component);\n\n  function Trash() {\n    var _ref;\n\n    var _temp, _this, _ret;\n\n    _classCallCheck(this, Trash);\n\n    for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {\n      args[_key] = arguments[_key];\n    }\n\n    return _ret = (_temp = (_this = _possibleConstructorReturn(this, (_ref = Trash.__proto__ || Object.getPrototypeOf(Trash)).call.apply(_ref, [this].concat(args))), _this), _this.state = {\n      hasMounted: false\n    }, _this.componentWillUpdate = function (nextProps) {\n      if (!_this.state.hasMounted && nextProps.shouldMount) {\n        _this.setState({ hasMounted: true });\n        _this.mountTrash();\n      }\n    }, _this.mountTrash = function () {\n      var _this2 = _this,\n          elm = _this2.elm;\n      var _this$props = _this.props,\n          width = _this$props.width,\n          height = _this$props.height,\n          onFpsUpdate = _this$props.onFpsUpdate;\n\n      (0, _trashController.trash)(elm, {\n        width: width,\n        height: height,\n        onFpsUpdate: onFpsUpdate\n      });\n    }, _temp), _possibleConstructorReturn(_this, _ret);\n  }\n\n  _createClass(Trash, [{\n    key: 'render',\n    value: function render() {\n      var _this3 = this;\n\n      var hasMounted = this.state.hasMounted;\n      var prefersReducedMotion = this.props.prefersReducedMotion;\n\n\n      if (prefersReducedMotion) {\n        return (0, _preact.h)(\n          'div',\n          { 'class': _Trash2.default.trash__fallback },\n          (0, _preact.h)('div', { 'class': _Trash2.default['trash__fallback-top'] }),\n          (0, _preact.h)('div', { 'class': _Trash2.default['trash__fallback-body'] })\n        );\n      }\n\n      return (0, _preact.h)('div', {\n        ref: function ref(elm) {\n          return _this3.elm = elm;\n        },\n        'class': (0, _bem.bem)(_Trash2.default.trash, hasMounted && 'active')\n      });\n    }\n  }]);\n\n  return Trash;\n}(_preact.Component);\n\n/***/ }),\n/* 26 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.trash = undefined;\n\nvar _matterJs = __webpack_require__(27);\n\nvar random = _matterJs.Common.random,\n    choose = _matterJs.Common.choose; //  @jsx h\n\nvar bodies = [{\n  width: 52,\n  height: 140,\n  base64: 'iVBORw0KGgoAAAANSUhEUgAAADQAAACMCAYAAAAz4YrzAAAAAXNSR0IArs4c6QAABhhJREFUeAHtXU9oXEUYn5n3NmmT1JPFJNKIQRRBqR7Ei4gRL4II9ZSiFy+2iAfBKranHMQgVJRKDyVKkYIJVCzqrUIqPQiit4DgsZhUWhU9xP373nz+ZnZn9721Uubl7brzsQvbt2935pv5ze/7vvnmezOpECW8iGgR7x/w1nj7vkwdU3exhK6UIwKdueCL4hblL5TRG1WGEMg4VIKcMmSIsgCVgKccEWNA5Yzj4KSMGRrc2JYjecxQOeM4OCljhgY3tuVIHjNUzjgOTsqYocGNbTmS2TEUFx2Xqy+fPJhWG4+TlPPXvtycq8xMFRVl67V2q3Oby2+8IomuR1OT3z95fvW3IgJlkUpXjp54XRCtYpG2r0j929WRUtaFlCeX1k9/eLuy/b97A/p2+cQRTfqLfkGDuFdSvfDUxulLPrK9bQhpg7d8GthLWRL0pm99b0Bo4LBvI4XLEz3iW9cbEAmx37eRouWLtOUNqGjnhlVvDGhYI120nTFDRUduWPXGDA1rpIu2M2ao6MgNq94tg1NauRLvzOy8qJR4HrP1g5LkLGm9X0gxQVQswZ/8/lchTFIKLUg0EH1XEdtto8NbEPTVwr6HLsmVpaRf6L8A7Zz5/FHRqK+j8gP9hfdyXxTQf7UphdwSKl6+Z/X4T9kyORu6+cHGs6JR+65sMNkGy/qMPj4sdOvH7VNnl7Iyu4D+OLt+qKXTT6FiA1m0ZRst67MJXpOUPrtxau0uJ7MLqF5P34OdHHQ/hHOl2ZpuvOv6awHRua+nhKYj7svQrshDHKWV81azLKCbjfoTIala/4Ab1fulUXvMfG8BJUnz/v5C4d2n93UBwc/fGR6AfI8xPVr7twwpor0l1fKy/6c7mjYNW0DYyjG0PMHA0FI712EBSUmFM6gD66CnYEy0FoMFhPis4ll/5IoDiMXQZghB0cj10LNDcAo9hgQDlRNZldM6fBsCoVmG2jeeLI9Y8YxTwAIuGrHeeXeHSGYY6uift5QRqoCVagaQbKMbof55dyU3D0keDPXmIURAli7vYRmpCsxsCGPbsyFN4btt6gQHNvRB/i14t53zcghOg7chEhkbQnYyeEB5hkT4Kpebh5BTCH49BIZ68xC2ogTvFHI2hD077GwoeECOlPY8xEDl8HjFkmIBIY0VPkPZ0AfzUPBOwa0YOlmf8AFRJziwgDjk5WRnLm0zxMAp5OehjkGN1HrNszPdWI5WCA8foIGBvxDLSYMFKncxeJfd4+JirG5M14MPTB2gX8WfsZqMD7ABNCmmY1VLa2xUrirqsaqkcsJRFvp1okkV1Yo0G5VryiRWkW6xUblIpLFK1QQbhhJZiZWihBdDSRyxAZRIDRtKIzYqFzVj2BBpNgyllqEoYTMPRZGoKJmGv1p1AUGaUKx0Gn7W1AFSRuW0UmycghZRrGIGy+8uQ3hWrBKZ8GEIT/EUNl2wcdsSD7+V+cdRFvrVPCNCgkSwmYdMbk5xSAM7zTJPwhXJlI1TMPltOIWYkQ3BKYiUT3AqsZFRIW/KiCGjcp0nX86wQr5KCZUjxWdixdk2MKQZRdtmHiLBxyng2A28HIPtmc7uzZEHMMTJy0leXg5MARBocpSFfm1H26zmIaic0HzmIdJG5RTxibYl5iEmJ1Oc+Zt5KPz9pg6NOUNkkiTBb1xygMwJFexT4OO2zW4SVqGPnYdYMYS4FJGC4mNDVuWI0Txk1kMcTqZ0vZxZPnA4meIAWS/H4WSKA2R2NZpUMJvlQ5shBidTegzBhnAyhQ9DJvThZUN2Cc6IIbMeMrksp4OhX80JFQU3xyb0MXl6RAp8lg82c8rpkWT7CR6neQhBApwCnzSWtSF4NjZOwa5YEf/UQnfXrv/Yp7BrTqZcd1+EfsXfz99GLCc3QweS6f832IguzuGkcZr5MsiPcAgpdm2vqdm3X9qC//4kSBT5Tn909zuv/mzP4M0dqL4GhFfzv4dzh+Dg8sJixf7nABaQPHasNX/H38+AqbWQ1M+oGfp7ZuHeiecMBkMBvHb+tf3+xmFFzePIEz+NwvOI9WbyJYrdlfWXaNGnXSxKr2Hn1WUpKx/3/yXafwAsdygwrPkCpAAAAABJRU5ErkJggg=='\n}, {\n  width: 94,\n  height: 206,\n  base64: 'iVBORw0KGgoAAAANSUhEUgAAAF4AAADOCAYAAAC3tLUtAAAAAXNSR0IArs4c6QAADFRJREFUeAHtnUuMHEcZgP+/etePteNH1o+AMV7sAAFiIEpQkDlFuSQ5EBJLkQAfQgKKD0SK4wsgFAWJG8QmDhGKSIAEEJCISBwChxxACihG8oUIYYSNSHAAP3b93PVjd6Z//uqZnumZ6Z5+VdVMz/wtrbu76n9UffO7urq6uhpgQBsR3cF/x/lv0NtRLsBnXGNA1w5Df1zZf/HxTHg+4P1xRPygyzIMEjy5rGiaLwbvlIVKK5Dk2yEg4O1wTbUq4FMR2REQ8Ha4ploV8KmI7AgIeDtcU60K+FREdgQEvB2uqVYFfCoiOwIC3g7XVKsCPhWRHQEBb4drqlUBn4rIjoCAt8M11aqAT0VkR0DA2+GaalXApyKyIzBI8G/bqVIhq8cLaZVQGiT4h7nc/yxRdlOqf2dDD5oyltWO0+eMulDzr927EzzvAIC6nR94X5e1oElyNH8iKStXOgJeZYUjpPBra3Yf/lMu5QLCTsHTG19Yf3lh6ahP/uYCZY1VMQU+NM6PvC+DUrddd//ho2Gajb3TpmZh/uq9JqHbAEIEU1Qn3Qxa3ZyCR1A7rNbGkHFEutmQqUQzTsFzKTYmlmSoMnCb7eK4BY+0wXaFjNgnGC3wPHWsEhFPQCsvvbprk5EfMcGI04jnLtR0QjmGLtlDmrFZKKfggbAy4Ou1utXmxi14xOttRpFJ29yfH42I1zdP3IdfZhKOTVtEOBrgF69eucEmKNO2uSMwGk2NogmrvQTT4PkmajQi/mqtXq2IJ7s3Ue4urh5UKuIBaDW9eqe1Xpgz8IpUJW6eok3WZVqw1s47Aw9UtYgH8H17XUp34KsyThMJeUS/+hFPiNUYIIuAJ8CZyKnRQ2cRj1SRkckIXn4oYg08j1vl24iem4Tzk/dwA/hZAPwU/00Dkb76L89nyZB0/RxfPvh2R296R37jgKmBzzn6vPWnD3U+//E+yNPnzXxi+eA4lEFvbnLztl+w4BIoXOKxphrn1/iY91ALDBH6oKjOHE6Cj++AWvMWbnz4Euf13XKBp7Mv3M1lPsQWb+xr1WUmgx+qDXEeEH4KsOzbuPHR/yaVLTN4mn3+q4DqEP/6mXWSnBpNHzbwYeUQToKH9+H0/sNhUnSfCSLN/WQ3QP1l/u/l7JoQLWTf42EFrwuNcAEmvU/i+n1vd9chFSTRS6uA6k8PJfTu2gzbOcFaWPJ/HlesVPBw7tpjrLglTlnSMhAg2kWnD97dLZkOntRD3UpynpMA1R/v1ugLnuZ+tIubmO3dSnKekwDiHXTpBx2DhH3Bs/me/yI5XYq4JkDkwZXL90RhpICnO6PCclyKQMfyW4ngeSYv5+HHS7kS5SiBbODh3Es383+RVVFNOS5F4Ca6cKA1yyIx4oFqPA4jmzEC+o6/5t8a2ksGD7gzFJK9IQJ19eHQUjJ48j8aCsneEAGkbaGlZPDQ/nVCYdmXJED0vtBCLHgec58CbAuFwrIvSwDfE1qIBQ9zyz4mg2IhIpN7as0tigfv4FUUk9WpjC3C1hSXBPB+6+pbmUpVoaAI64l+P6GLGg+e8ENVqEflyqj78gt/0c+nE8ADOF1ZunIAyxT4KgV3r/ERD/iBMrZFtw8Bvx4f8TwGv1XGaPqAK5vVfCsmJuLpI2Vti34fAj6s07m94BXe1EdNssoSwCTwRMMzWalsJYdRn7uUuli9EU9UifUGhpFppjL5tDYevPRoMvErLISYAJ5wprBRUcxAgNZooY6mhmZf5IlLtDKDtogUJUBxEe/VZKigKNDMejERD76SHk1mgIUFg3XYOpoavmMV8IV5ZlREjAGvaCajuogVJxAD3sHKRMXLOyqatFrXpLOpAXj/qFRvaOtBMEF0aHkLPNHLekkTY+tBDm3Fh6FgF2urWuBh7sIOecDt6Fepe6vb4JWaceRW3Ph+JOLrdhfGEdoRAjwZuB3xHsmFNcLG6iGpqTZ4HwW8VdpR4/5UMMcjSFK4Rb+CLluEAOL/eNDwGKdc4pc0NvOdvV5zeEVEotghYQS8L3MlA4q8GBnDfoXfYv8Obnz8SJRs8M7v7OnP8ZoGT5YaXvH8qdab3Ty7YL6SswtMvtmNeJFBfx437f9tFHj3cXDPc+bEs8zry915mc4VPBI0NXTxxWlYrI35azd4DTx1F07vezMNHuIDiyzzFTr1Xb2Cx940+Z58whWNi+uiv70nc9wSFHwjC/QOLJtufZTP/9qRluWEsDlk4I35K/MI78KGrd/Pwiwqw+8N1/h/yTejaZmOFTUjvl5/byaFURUieKXZfOSv4fQtrwHi+VyKraYGVetNhVwGRkbY+2PRqgRRD/DnXPoURjzQeIOf8BNXUsoGlPLpYwiexnw4uK70N6CKbxh8QyqHftirQb4rk80dAYLmxRWoY0kPdyUYU0/tpgYFvNsYWK5o7mc8pUxmj7nljpN857rYetvYrfOx9sbglV+5NX9H4CfTEa+CifIjUJnqVIGIwfvVW2y5OoQTSoq6jfdJIj6Bj7VkAgbvQWu5JmuOxHAnAdTgfZSI78Ti4Ey38UqaGgekO11Q0MZLU9NJxcFZ0NQgBi9DOXAnLkICwcUVccwfcoc0nO6V4ikKU05dijOeGwUMHrD8zCiBmZeABg8S8XmxlZcPwE+WtyMWchHgJbK4jed7V9kcE0COeBTwjqlrd0FT056qPYASjKXLRq9mLKs+4ErrNp4/8jTgUoyje93G80cCZXNLgL8gp3s1S269ijdNQN9A6Un2sjkmoNt4Ae8YunanI77chM0BFNq4S6RyXWofcutzG49XjFekcgbbC+oXLHruSb+6qRHwALcUBN5Qw/z6uju5UMrpKCgT7C5aDZr93u38TGNrXn39IETAE32CTh28Py+8QN6vP1lET19c54sojpwO1p+l2QO87mb2jc4c2MuBe1d2jbakHp3k9/Rl4xvJG3hW3et0/uD2LDTo9FMPAfnPZJGNk+GIxwtxGWOZRrx2/mL9CJ156jGiH8c+EqXTB25k6L/kSH+Bf6zc3ciQK9Lc89/iLuUTYULl9ibXMohWHpHXdoDXuUX4ByfrVoG7jPRpDtTbGHprDYioSp7jCZ7Cd4GNy9ZNgIJlCu9j+F1bT0JXfrZTPYUv31vJ2eyKVAoBBq/mUmQk2wIBvrj65yzYFZMpBHiati8RnwLJRraC5ZMC3gbZFJsKVs3M8niNmUt1ijPJbhNQwbIfRDJs0Gbi5EiP1fCGcoFtgHD2bwM8koB3hrzhqAGe4Kxjv2PvrhnxID0bx6HQjHg849jv2LtrRjzOjj0JxwCaEb8kET8Q8AoE/EDAI5507Hfs3TWamjqcGnsSjgE0wHsTvEC9bC4JBOBx/ZfO80CZTF51SL4R8Q2H0qUcDHgS8IMBD6cd+h17V9GmRvryDsMhCl66lAMBj76AHwh4X39sSjZXBNpNTfCVL1duxU8EfM7PLQi7UgTa4NXK/5SyJMq5CLTA47ov6gfe13Jpi3BhAi3wTQvSly+MMp9iF3iULmU+foWlO8FLX74wyLyKneBByZOovAQLyneBh3xf8CroVNQai0i0OZAvd69tGlaPOiPeU9KXt4q7bbwTfB2lqWmzsXrUCX4FnLDqTYy3CHSCX/XgKVDy0LtFx+JBB3jUr+T48uzVIu+W6Q7wjVSZVdaiY/GgFzz6chNlEXhouhc8yJOoEI7NfQx4kr68TeJN2zHgvXcd+B17F73g0RfwDsKiFzyQ3EQNBDyt+LcDv2PvoificXrPRV6xSV6xtxwaPeADfySPAC1zDxZ17vWBvoxS9lIxmhIf8ShPooxSjjEWD55QbqJiYJlMigfvg4A3STnGVjx4JX35GFZGk+LBgyc3UUYx9xqLB79i4p1eUUkxSSAe/NSek/II0CTmXlux4JuPAGUeZS8vYymx4BvW5UUFY5RjDCWDR5ncFMPLWFIf8PIkyhjlGEPJ4AHlgUgMMENJi8ngPZlVZghyrxmEhWTwS7JcVi8xYylnk8F7k/I+lDHO3YbwWDL4dZf/xmsOywcYu5mZOEd4KxE84iNL/P2QN034ERvdBNTvEsEHoohPd6vIeUkCCMdgw5Y3+oLH9Q/9BpB+VdKVqEcJEH4d8YF6X/CB/PU79vCsgx/KVxWi9Aoc6ynwCp/Azft/rbUzf3qLzj63E3xvL2vs4nfW+DOatLbMJ9cKFD1exdaXz+K95UtFrDMnPdh4GNB7Bjfu+0No4P9VDlY8XSOTGwAAAABJRU5ErkJggg=='\n}, {\n  width: 56,\n  height: 158,\n  base64: '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'\n}, {\n  width: 70,\n  height: 98,\n  base64: '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'\n}, {\n  width: 46,\n  height: 64,\n  base64: 'iVBORw0KGgoAAAANSUhEUgAAAC4AAABACAYAAABlR0UdAAAAAXNSR0IArs4c6QAAA55JREFUaAXVmsFOGzEQhj3eTRpaVc2Rc58ACRQpKkilufXWvhB9Al6hZ0DqI1BEUXPoQ1TqoaQENXBppZKsO7PZeO21HRBydid7YHdtZ/z5z9iejIF3F8PPQqjXIvL148/fyBZLcwBwJgGSg7JoPZ5AqgP56VXvHECcrgcyUcLpt8HgPJ0DJ4f97vM3MeH73W5Mc9rW0eXokF4k/UkS9Z3u63ClkOasueJpml4Nb26icq9qcj7ttMYEmis+3d6e4EzNopKvwhiA2tzb+63BTwBmuCRer6KvqDaVuJ6zFornxpXIv4KoHUU2BkJcLUzmrpK/AOjCRSW7O5TianC1Boorn+JSKP6uYoirFUe3YO8qIR9nr3gGpVcYivOfnABSi6vBlSgL2a0mBRDukdqdNTiORhdyBU+y1FX8WTLThVzBM+hocbXiL3s97vFK9nbQmyxE1eAf0IFwgWerOv7YGROjA04FwHkTUmCJqhUvRqJ9aDEyLndlrOHEVAG3R8UFmjhA2PtMBZzztl/umjQQGxz4Kq4qYbcNLsqdiUbF6spsUS1wzA5ZM5cTuARlLRwWuJjxjVfMAIsEtcBB8I1XMmm7sQUu5B1bV2l1OhabBX7c70/wVwamKnhdxPQV2UyqInc4L8KkkHp/MRz3uy82zUaPeY6ZOzy+HI2JzeSwFC8qrNlrNm7qWXliKEtxAqOYIEYeMWbuENV2xHQUx5jAmgRNqWz1q+ztnuocxXEk416E3HZMHz/6ObpfccFx96yEtF7Fcer+Yufj0t3RHR9XImPn4xhDPchVnEbWRGngZZa5k9NRvOX5WhpgtbpMIHXEdMA32m2nkWWlgZf2Ezf74IB/3Nq6RbZpA3zeLnHzmX7Z3XVO1hxwigkwqGEzQenAoRqn0Agd8Pmw3VnslaOeQq/rBsD5KE4ZLJ8+IXDvKH0Gaih7OHg1a1QDXLALZPGK6FUcp6e3cdD6CitAuds9decHD/jVCvmCpiGQ6/GCC+OsJWixpooswOIFryYYa2L0diONcx+zgRdcST4RopyV5z73gkv8/xWzUZPPGy2/iF7FT3Z2bnGb/dckcN43wN3Z/r4Tp1CdF7wA9i78RV1NNzcOX3QcBPflMhYfquu+bD8JgiMcAz9/hOIc8ivVUwjzmw4rXjmeMz9U1/Oy48sweCUfXRes2Q+ubEF3DYNXzlxMg3U9Z0sYwuAMJif+igwuyUHwJBDc1KU29SOX/CvKf2qQAQ7MvtQSAAAAAElFTkSuQmCC'\n}, {\n  // fork\n  width: 18,\n  height: 110,\n  base64: 'iVBORw0KGgoAAAANSUhEUgAAABIAAABuCAYAAAAqLkPtAAAAAXNSR0IArs4c6QAAA2dJREFUWAntWT2LFEEQ3fXrPPU8P+5Q8BeIYGasoX/CWEEwMRJMzEz9A4KJgbEIgpFgJpcoGJgrihxyiujeeet7zdTy7K6e6WlmRZZrqO2erqpXr6q7Z4bZ0XQ6HUOeQLYgN0ZRw9wtyEfIY8h+VeP6IWQTcnuEn0sQa+/VkGMoPpgS/UXTY3xW5rf2QbFuSvTnZGzDVRugPyzjMzJeIdCKTCwjygG7xniM8bJdo+e1tRM2YB8Dce4Yf5p2BL06097aSRugn1KhjtTp9VFOSFNQBQqMYmNNVUGJp0CnJIDLSIHbgJRRAFJHBlHnWJdjtMsaxcYKpGMG0WInqXFltClwDNTKSPcJAdVZx9QpkNYopDYYoz5AuRoFRr1Tw9HhXUDPYABaYvLSSorNc6b1+k2qfYAsNV16cghAemvgZBsju7Gt0VBab0Y5oB1SPSTIHLYxsrqcjnwCo9mNrFG2AeUYbZORKS2I7isFpd6KHdcoANUwildt0sUod9biGm2TjRXQUjvePAAYRO+W1Jut7mrOTwg0FQNOsi6PINTFK3oHQfhsuwLR9pNP2QlmDupsxfgp6f+qcIxdfhDoezxbcR0e2V8qHGOXTTJ6G89WXL8j0PMKx9jlBV9b1iHfILXt2QwVCHcrUSbwO69AfJ151RNsF/bXZiA2wOQq5HUh2A7sbppv0kO5BLkPoWGu8VXwcuLsTcDwQQ4F81c9Hy6/1+yUezrXx52Ed3zqFTB+fAVdDsg1btDcIDkg17gBcoPkgFzjoYFctnNn5EYdOjW3frnU2hi5uhqgXoxc45oaufQbIFeXS+2fMHKD5Bi59Gtq5EbtVSPcAXlTa3upcIN4qbWBkJSbtgfkRmzSYufqPSA34jyA3EBzZeTWYDFSc4spqbn6uRbbjSiM+G6e7P4aRsRMgtUCJVukFmiPkax1ZlhUo2SPOGALvGpFqZXUqKjYiZFT7MSm9ogUpZZEq2VUUqM9Rk51o6n/r0bJFvE25AIvf0lqRTVKjKKl52ViU1vswYCKNuRgNVpgoPhrsrP6HcvvvdJ5KCX7qIQNsTv3UcmKFQENxqgUKGEenzV+2+aH8q6WfLr+C2g8Hn8FwkYXCvTd33exBS5APkNy7Q0U+q9xPi4M1yD3IBsQ/ln+CfISch0S/40WgP4AB/oWX2xvlAcAAAAASUVORK5CYII='\n}, {\n  // sucking tube\n  width: 22,\n  height: 136,\n  base64: 'iVBORw0KGgoAAAANSUhEUgAAABYAAACICAYAAADj2BsIAAAAAXNSR0IArs4c6QAAAaBJREFUaAXtlSFIQ2EUhZ86EdEgFsOyRcw2Ma1YBMFmsgpGm3VgFAxGwWayiAwMlmHRNBAELRoFDUMUZb6dh+xwkDfm7lOL58HPvv/B/TY+Lpok//JJ03QS5xznFGfsRyJANIpTx+k8x4ChQvJMgHPUMcrnblHxnsgU78NiWLbUJPwGroTEGFwTkeIHLqtR6SKG39UmvBmVzkHyLCLFnah0GpYHNQkfggf7FmNoCudWRIpnuIxEpOMYvFSTcAM8EZEOY7AmIsU7XMoR6QAGD9Qk/Aie6VuaDWBwW0SKL7jMR6UbahJugZej0hUMZ4K8Zz0qXYDtNc+Id9WodBbDT12k+yFpNgThdRfpCd6XiojzvBd4WexfTZ4V75aiv7TXH47mb4mj3qTXL7Y4XICDbuwULEDwVjgFCxC8FU7BAgRvhVOwAMFb4RQsQPBWOAULELwVTsECBG+FU7AAwVvhFCxA8FY4BQsQvBVOwQIEb4VTsADBW+EULEDwVjgFCxC8FU7BAgRvhVOwAMFb4RQsQPBW/G2KG37dJzTwcfXl3bevbc3qaR0v93P/AAAAAElFTkSuQmCC'\n}];\n\nvar trash = function trash(elm, opts) {\n  var engine = _matterJs.Engine.create();\n  var width = opts.width,\n      height = opts.height,\n      onFpsUpdate = opts.onFpsUpdate;\n\n\n  var render = _matterJs.Render.create({\n    element: elm,\n    engine: engine,\n    options: {\n      width: width,\n      height: height,\n      wireframes: false,\n      background: 'transparent'\n    }\n  });\n\n  _matterJs.Render.run(render);\n\n  var runner = _matterJs.Runner.create();\n  _matterJs.Runner.run(runner, engine);\n\n  setTimeout(function () {\n    onFpsUpdate(runner.fps);\n  }, 1000);\n\n  setInterval(function () {\n    onFpsUpdate(runner.fps);\n  }, 5000);\n\n  var world = engine.world;\n  world.gravity.scale = 0;\n\n  setInterval(function () {\n    var bodiesToRemove = world.bodies.filter(function (item) {\n      return item.position.x > width + 10 || item.position.y > height + 100;\n    });\n    bodiesToRemove.forEach(function (composite) {\n      _matterJs.Composite.remove(world, composite);\n    });\n    addBodiesWithSprites(world, {\n      numberOfBodies: bodiesToRemove.length,\n      width: width,\n      height: height\n    });\n  }, 100);\n\n  var bodiesFromWidth = width / 7;\n  var maxNumberOfBodies = 150;\n  var numberOfBodies = bodiesFromWidth > maxNumberOfBodies ? maxNumberOfBodies : bodiesFromWidth;\n  addBodiesWithSprites(world, { numberOfBodies: numberOfBodies, width: width, height: height, fill: true });\n\n  _matterJs.World.add(world, [_matterJs.Bodies.rectangle(width / 2, height + 2.5, width + 200, 5, {\n    isStatic: true,\n    render: { fillStyle: 'transparent' }\n  }), _matterJs.Bodies.rectangle(width / 2, 22, width + 200, 5, {\n    isStatic: true,\n    render: { fillStyle: 'transparent' }\n  })]);\n};\n\nfunction addBodiesWithSprites(composite, _ref) {\n  var numberOfBodies = _ref.numberOfBodies,\n      width = _ref.width,\n      height = _ref.height,\n      fill = _ref.fill;\n\n  var _loop = function _loop(i) {\n    var x = fill ? random(0, width) : -100;\n    var y = random(40, height - 100);\n    var body = choose(bodies.map(function (sprite) {\n      return addBody(sprite, { x: x, y: y });\n    }));\n\n    var xVelocity = random(3, 4);\n    var yVelocity = random(-0.2, 1.5);\n\n    _matterJs.Body.setVelocity(body, {\n      x: xVelocity,\n      y: yVelocity\n    });\n\n    _matterJs.World.add(composite, body);\n  };\n\n  for (var i = 0; i < numberOfBodies; i += 1) {\n    _loop(i);\n  }\n}\n\nfunction addBody(sprite, _ref2) {\n  var x = _ref2.x,\n      y = _ref2.y;\n\n  return _matterJs.Bodies.rectangle(x, y, sprite.width / 2 / 2, sprite.height / 2 / 2, {\n    friction: 0,\n    frictionAir: 0,\n    angle: random(Math.PI * 0.01, Math.PI),\n    render: {\n      strokeStyle: '#fff',\n      sprite: {\n        texture: 'data:image/png;base64,' + sprite.base64,\n        xScale: 0.3,\n        yScale: 0.3\n      }\n    }\n  });\n}\n\nexports.trash = trash;\n\n/***/ }),\n/* 27 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/* WEBPACK VAR INJECTION */(function(global) {var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;var require;var require;\n\nvar _typeof = typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; };\n\n/**\n* matter-js 0.14.1 by @liabru 2018-01-10\n* http://brm.io/matter-js/\n* License MIT\n*/\n\n/**\n * The MIT License (MIT)\n * \n * Copyright (c) Liam Brummitt and contributors.\n * \n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n * \n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n * \n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\n(function (f) {\n    if (( false ? \"undefined\" : _typeof(exports)) === \"object\" && typeof module !== \"undefined\") {\n        module.exports = f();\n    } else if (true) {\n        !(__WEBPACK_AMD_DEFINE_ARRAY__ = [], __WEBPACK_AMD_DEFINE_FACTORY__ = (f),\n\t\t\t\t__WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ?\n\t\t\t\t(__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__),\n\t\t\t\t__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));\n    } else {\n        var g;if (typeof window !== \"undefined\") {\n            g = window;\n        } else if (typeof global !== \"undefined\") {\n            g = global;\n        } else if (typeof self !== \"undefined\") {\n            g = self;\n        } else {\n            g = this;\n        }g.Matter = f();\n    }\n})(function () {\n    var define, module, exports;return function e(t, n, r) {\n        function s(o, u) {\n            if (!n[o]) {\n                if (!t[o]) {\n                    var a = typeof require == \"function\" && require;if (!u && a) return require(o, !0);if (i) return i(o, !0);var f = new Error(\"Cannot find module '\" + o + \"'\");throw f.code = \"MODULE_NOT_FOUND\", f;\n                }var l = n[o] = { exports: {} };t[o][0].call(l.exports, function (e) {\n                    var n = t[o][1][e];return s(n ? n : e);\n                }, l, l.exports, e, t, n, r);\n            }return n[o].exports;\n        }var i = typeof require == \"function\" && require;for (var o = 0; o < r.length; o++) {\n            s(r[o]);\n        }return s;\n    }({ 1: [function (_dereq_, module, exports) {\n            /**\n            * The `Matter.Body` module contains methods for creating and manipulating body models.\n            * A `Matter.Body` is a rigid body that can be simulated by a `Matter.Engine`.\n            * Factories for commonly used body configurations (such as rectangles, circles and other polygons) can be found in the module `Matter.Bodies`.\n            *\n            * See the included usage [examples](https://github.com/liabru/matter-js/tree/master/examples).\n            \n            * @class Body\n            */\n\n            var Body = {};\n\n            module.exports = Body;\n\n            var Vertices = _dereq_('../geometry/Vertices');\n            var Vector = _dereq_('../geometry/Vector');\n            var Sleeping = _dereq_('../core/Sleeping');\n            var Render = _dereq_('../render/Render');\n            var Common = _dereq_('../core/Common');\n            var Bounds = _dereq_('../geometry/Bounds');\n            var Axes = _dereq_('../geometry/Axes');\n\n            (function () {\n\n                Body._inertiaScale = 4;\n                Body._nextCollidingGroupId = 1;\n                Body._nextNonCollidingGroupId = -1;\n                Body._nextCategory = 0x0001;\n\n                /**\n                 * Creates a new rigid body model. The options parameter is an object that specifies any properties you wish to override the defaults.\n                 * All properties have default values, and many are pre-calculated automatically based on other properties.\n                 * Vertices must be specified in clockwise order.\n                 * See the properties section below for detailed information on what you can pass via the `options` object.\n                 * @method create\n                 * @param {} options\n                 * @return {body} body\n                 */\n                Body.create = function (options) {\n                    var defaults = {\n                        id: Common.nextId(),\n                        type: 'body',\n                        label: 'Body',\n                        parts: [],\n                        plugin: {},\n                        angle: 0,\n                        vertices: Vertices.fromPath('L 0 0 L 40 0 L 40 40 L 0 40'),\n                        position: { x: 0, y: 0 },\n                        force: { x: 0, y: 0 },\n                        torque: 0,\n                        positionImpulse: { x: 0, y: 0 },\n                        constraintImpulse: { x: 0, y: 0, angle: 0 },\n                        totalContacts: 0,\n                        speed: 0,\n                        angularSpeed: 0,\n                        velocity: { x: 0, y: 0 },\n                        angularVelocity: 0,\n                        isSensor: false,\n                        isStatic: false,\n                        isSleeping: false,\n                        motion: 0,\n                        sleepThreshold: 60,\n                        density: 0.001,\n                        restitution: 0,\n                        friction: 0.1,\n                        frictionStatic: 0.5,\n                        frictionAir: 0.01,\n                        collisionFilter: {\n                            category: 0x0001,\n                            mask: 0xFFFFFFFF,\n                            group: 0\n                        },\n                        slop: 0.05,\n                        timeScale: 1,\n                        render: {\n                            visible: true,\n                            opacity: 1,\n                            sprite: {\n                                xScale: 1,\n                                yScale: 1,\n                                xOffset: 0,\n                                yOffset: 0\n                            },\n                            lineWidth: 0\n                        }\n                    };\n\n                    var body = Common.extend(defaults, options);\n\n                    _initProperties(body, options);\n\n                    return body;\n                };\n\n                /**\n                 * Returns the next unique group index for which bodies will collide.\n                 * If `isNonColliding` is `true`, returns the next unique group index for which bodies will _not_ collide.\n                 * See `body.collisionFilter` for more information.\n                 * @method nextGroup\n                 * @param {bool} [isNonColliding=false]\n                 * @return {Number} Unique group index\n                 */\n                Body.nextGroup = function (isNonColliding) {\n                    if (isNonColliding) return Body._nextNonCollidingGroupId--;\n\n                    return Body._nextCollidingGroupId++;\n                };\n\n                /**\n                 * Returns the next unique category bitfield (starting after the initial default category `0x0001`).\n                 * There are 32 available. See `body.collisionFilter` for more information.\n                 * @method nextCategory\n                 * @return {Number} Unique category bitfield\n                 */\n                Body.nextCategory = function () {\n                    Body._nextCategory = Body._nextCategory << 1;\n                    return Body._nextCategory;\n                };\n\n                /**\n                 * Initialises body properties.\n                 * @method _initProperties\n                 * @private\n                 * @param {body} body\n                 * @param {} [options]\n                 */\n                var _initProperties = function _initProperties(body, options) {\n                    options = options || {};\n\n                    // init required properties (order is important)\n                    Body.set(body, {\n                        bounds: body.bounds || Bounds.create(body.vertices),\n                        positionPrev: body.positionPrev || Vector.clone(body.position),\n                        anglePrev: body.anglePrev || body.angle,\n                        vertices: body.vertices,\n                        parts: body.parts || [body],\n                        isStatic: body.isStatic,\n                        isSleeping: body.isSleeping,\n                        parent: body.parent || body\n                    });\n\n                    Vertices.rotate(body.vertices, body.angle, body.position);\n                    Axes.rotate(body.axes, body.angle);\n                    Bounds.update(body.bounds, body.vertices, body.velocity);\n\n                    // allow options to override the automatically calculated properties\n                    Body.set(body, {\n                        axes: options.axes || body.axes,\n                        area: options.area || body.area,\n                        mass: options.mass || body.mass,\n                        inertia: options.inertia || body.inertia\n                    });\n\n                    // render properties\n                    var defaultFillStyle = body.isStatic ? '#2e2b44' : Common.choose(['#006BA6', '#0496FF', '#FFBC42', '#D81159', '#8F2D56']),\n                        defaultStrokeStyle = '#000';\n                    body.render.fillStyle = body.render.fillStyle || defaultFillStyle;\n                    body.render.strokeStyle = body.render.strokeStyle || defaultStrokeStyle;\n                    body.render.sprite.xOffset += -(body.bounds.min.x - body.position.x) / (body.bounds.max.x - body.bounds.min.x);\n                    body.render.sprite.yOffset += -(body.bounds.min.y - body.position.y) / (body.bounds.max.y - body.bounds.min.y);\n                };\n\n                /**\n                 * Given a property and a value (or map of), sets the property(s) on the body, using the appropriate setter functions if they exist.\n                 * Prefer to use the actual setter functions in performance critical situations.\n                 * @method set\n                 * @param {body} body\n                 * @param {} settings A property name (or map of properties and values) to set on the body.\n                 * @param {} value The value to set if `settings` is a single property name.\n                 */\n                Body.set = function (body, settings, value) {\n                    var property;\n\n                    if (typeof settings === 'string') {\n                        property = settings;\n                        settings = {};\n                        settings[property] = value;\n                    }\n\n                    for (property in settings) {\n                        value = settings[property];\n\n                        if (!settings.hasOwnProperty(property)) continue;\n\n                        switch (property) {\n\n                            case 'isStatic':\n                                Body.setStatic(body, value);\n                                break;\n                            case 'isSleeping':\n                                Sleeping.set(body, value);\n                                break;\n                            case 'mass':\n                                Body.setMass(body, value);\n                                break;\n                            case 'density':\n                                Body.setDensity(body, value);\n                                break;\n                            case 'inertia':\n                                Body.setInertia(body, value);\n                                break;\n                            case 'vertices':\n                                Body.setVertices(body, value);\n                                break;\n                            case 'position':\n                                Body.setPosition(body, value);\n                                break;\n                            case 'angle':\n                                Body.setAngle(body, value);\n                                break;\n                            case 'velocity':\n                                Body.setVelocity(body, value);\n                                break;\n                            case 'angularVelocity':\n                                Body.setAngularVelocity(body, value);\n                                break;\n                            case 'parts':\n                                Body.setParts(body, value);\n                                break;\n                            default:\n                                body[property] = value;\n\n                        }\n                    }\n                };\n\n                /**\n                 * Sets the body as static, including isStatic flag and setting mass and inertia to Infinity.\n                 * @method setStatic\n                 * @param {body} body\n                 * @param {bool} isStatic\n                 */\n                Body.setStatic = function (body, isStatic) {\n                    for (var i = 0; i < body.parts.length; i++) {\n                        var part = body.parts[i];\n                        part.isStatic = isStatic;\n\n                        if (isStatic) {\n                            part._original = {\n                                restitution: part.restitution,\n                                friction: part.friction,\n                                mass: part.mass,\n                                inertia: part.inertia,\n                                density: part.density,\n                                inverseMass: part.inverseMass,\n                                inverseInertia: part.inverseInertia\n                            };\n\n                            part.restitution = 0;\n                            part.friction = 1;\n                            part.mass = part.inertia = part.density = Infinity;\n                            part.inverseMass = part.inverseInertia = 0;\n\n                            part.positionPrev.x = part.position.x;\n                            part.positionPrev.y = part.position.y;\n                            part.anglePrev = part.angle;\n                            part.angularVelocity = 0;\n                            part.speed = 0;\n                            part.angularSpeed = 0;\n                            part.motion = 0;\n                        } else if (part._original) {\n                            part.restitution = part._original.restitution;\n                            part.friction = part._original.friction;\n                            part.mass = part._original.mass;\n                            part.inertia = part._original.inertia;\n                            part.density = part._original.density;\n                            part.inverseMass = part._original.inverseMass;\n                            part.inverseInertia = part._original.inverseInertia;\n\n                            delete part._original;\n                        }\n                    }\n                };\n\n                /**\n                 * Sets the mass of the body. Inverse mass, density and inertia are automatically updated to reflect the change.\n                 * @method setMass\n                 * @param {body} body\n                 * @param {number} mass\n                 */\n                Body.setMass = function (body, mass) {\n                    var moment = body.inertia / (body.mass / 6);\n                    body.inertia = moment * (mass / 6);\n                    body.inverseInertia = 1 / body.inertia;\n\n                    body.mass = mass;\n                    body.inverseMass = 1 / body.mass;\n                    body.density = body.mass / body.area;\n                };\n\n                /**\n                 * Sets the density of the body. Mass and inertia are automatically updated to reflect the change.\n                 * @method setDensity\n                 * @param {body} body\n                 * @param {number} density\n                 */\n                Body.setDensity = function (body, density) {\n                    Body.setMass(body, density * body.area);\n                    body.density = density;\n                };\n\n                /**\n                 * Sets the moment of inertia (i.e. second moment of area) of the body of the body. \n                 * Inverse inertia is automatically updated to reflect the change. Mass is not changed.\n                 * @method setInertia\n                 * @param {body} body\n                 * @param {number} inertia\n                 */\n                Body.setInertia = function (body, inertia) {\n                    body.inertia = inertia;\n                    body.inverseInertia = 1 / body.inertia;\n                };\n\n                /**\n                 * Sets the body's vertices and updates body properties accordingly, including inertia, area and mass (with respect to `body.density`).\n                 * Vertices will be automatically transformed to be orientated around their centre of mass as the origin.\n                 * They are then automatically translated to world space based on `body.position`.\n                 *\n                 * The `vertices` argument should be passed as an array of `Matter.Vector` points (or a `Matter.Vertices` array).\n                 * Vertices must form a convex hull, concave hulls are not supported.\n                 *\n                 * @method setVertices\n                 * @param {body} body\n                 * @param {vector[]} vertices\n                 */\n                Body.setVertices = function (body, vertices) {\n                    // change vertices\n                    if (vertices[0].body === body) {\n                        body.vertices = vertices;\n                    } else {\n                        body.vertices = Vertices.create(vertices, body);\n                    }\n\n                    // update properties\n                    body.axes = Axes.fromVertices(body.vertices);\n                    body.area = Vertices.area(body.vertices);\n                    Body.setMass(body, body.density * body.area);\n\n                    // orient vertices around the centre of mass at origin (0, 0)\n                    var centre = Vertices.centre(body.vertices);\n                    Vertices.translate(body.vertices, centre, -1);\n\n                    // update inertia while vertices are at origin (0, 0)\n                    Body.setInertia(body, Body._inertiaScale * Vertices.inertia(body.vertices, body.mass));\n\n                    // update geometry\n                    Vertices.translate(body.vertices, body.position);\n                    Bounds.update(body.bounds, body.vertices, body.velocity);\n                };\n\n                /**\n                 * Sets the parts of the `body` and updates mass, inertia and centroid.\n                 * Each part will have its parent set to `body`.\n                 * By default the convex hull will be automatically computed and set on `body`, unless `autoHull` is set to `false.`\n                 * Note that this method will ensure that the first part in `body.parts` will always be the `body`.\n                 * @method setParts\n                 * @param {body} body\n                 * @param [body] parts\n                 * @param {bool} [autoHull=true]\n                 */\n                Body.setParts = function (body, parts, autoHull) {\n                    var i;\n\n                    // add all the parts, ensuring that the first part is always the parent body\n                    parts = parts.slice(0);\n                    body.parts.length = 0;\n                    body.parts.push(body);\n                    body.parent = body;\n\n                    for (i = 0; i < parts.length; i++) {\n                        var part = parts[i];\n                        if (part !== body) {\n                            part.parent = body;\n                            body.parts.push(part);\n                        }\n                    }\n\n                    if (body.parts.length === 1) return;\n\n                    autoHull = typeof autoHull !== 'undefined' ? autoHull : true;\n\n                    // find the convex hull of all parts to set on the parent body\n                    if (autoHull) {\n                        var vertices = [];\n                        for (i = 0; i < parts.length; i++) {\n                            vertices = vertices.concat(parts[i].vertices);\n                        }\n\n                        Vertices.clockwiseSort(vertices);\n\n                        var hull = Vertices.hull(vertices),\n                            hullCentre = Vertices.centre(hull);\n\n                        Body.setVertices(body, hull);\n                        Vertices.translate(body.vertices, hullCentre);\n                    }\n\n                    // sum the properties of all compound parts of the parent body\n                    var total = Body._totalProperties(body);\n\n                    body.area = total.area;\n                    body.parent = body;\n                    body.position.x = total.centre.x;\n                    body.position.y = total.centre.y;\n                    body.positionPrev.x = total.centre.x;\n                    body.positionPrev.y = total.centre.y;\n\n                    Body.setMass(body, total.mass);\n                    Body.setInertia(body, total.inertia);\n                    Body.setPosition(body, total.centre);\n                };\n\n                /**\n                 * Sets the position of the body instantly. Velocity, angle, force etc. are unchanged.\n                 * @method setPosition\n                 * @param {body} body\n                 * @param {vector} position\n                 */\n                Body.setPosition = function (body, position) {\n                    var delta = Vector.sub(position, body.position);\n                    body.positionPrev.x += delta.x;\n                    body.positionPrev.y += delta.y;\n\n                    for (var i = 0; i < body.parts.length; i++) {\n                        var part = body.parts[i];\n                        part.position.x += delta.x;\n                        part.position.y += delta.y;\n                        Vertices.translate(part.vertices, delta);\n                        Bounds.update(part.bounds, part.vertices, body.velocity);\n                    }\n                };\n\n                /**\n                 * Sets the angle of the body instantly. Angular velocity, position, force etc. are unchanged.\n                 * @method setAngle\n                 * @param {body} body\n                 * @param {number} angle\n                 */\n                Body.setAngle = function (body, angle) {\n                    var delta = angle - body.angle;\n                    body.anglePrev += delta;\n\n                    for (var i = 0; i < body.parts.length; i++) {\n                        var part = body.parts[i];\n                        part.angle += delta;\n                        Vertices.rotate(part.vertices, delta, body.position);\n                        Axes.rotate(part.axes, delta);\n                        Bounds.update(part.bounds, part.vertices, body.velocity);\n                        if (i > 0) {\n                            Vector.rotateAbout(part.position, delta, body.position, part.position);\n                        }\n                    }\n                };\n\n                /**\n                 * Sets the linear velocity of the body instantly. Position, angle, force etc. are unchanged. See also `Body.applyForce`.\n                 * @method setVelocity\n                 * @param {body} body\n                 * @param {vector} velocity\n                 */\n                Body.setVelocity = function (body, velocity) {\n                    body.positionPrev.x = body.position.x - velocity.x;\n                    body.positionPrev.y = body.position.y - velocity.y;\n                    body.velocity.x = velocity.x;\n                    body.velocity.y = velocity.y;\n                    body.speed = Vector.magnitude(body.velocity);\n                };\n\n                /**\n                 * Sets the angular velocity of the body instantly. Position, angle, force etc. are unchanged. See also `Body.applyForce`.\n                 * @method setAngularVelocity\n                 * @param {body} body\n                 * @param {number} velocity\n                 */\n                Body.setAngularVelocity = function (body, velocity) {\n                    body.anglePrev = body.angle - velocity;\n                    body.angularVelocity = velocity;\n                    body.angularSpeed = Math.abs(body.angularVelocity);\n                };\n\n                /**\n                 * Moves a body by a given vector relative to its current position, without imparting any velocity.\n                 * @method translate\n                 * @param {body} body\n                 * @param {vector} translation\n                 */\n                Body.translate = function (body, translation) {\n                    Body.setPosition(body, Vector.add(body.position, translation));\n                };\n\n                /**\n                 * Rotates a body by a given angle relative to its current angle, without imparting any angular velocity.\n                 * @method rotate\n                 * @param {body} body\n                 * @param {number} rotation\n                 * @param {vector} [point]\n                 */\n                Body.rotate = function (body, rotation, point) {\n                    if (!point) {\n                        Body.setAngle(body, body.angle + rotation);\n                    } else {\n                        var cos = Math.cos(rotation),\n                            sin = Math.sin(rotation),\n                            dx = body.position.x - point.x,\n                            dy = body.position.y - point.y;\n\n                        Body.setPosition(body, {\n                            x: point.x + (dx * cos - dy * sin),\n                            y: point.y + (dx * sin + dy * cos)\n                        });\n\n                        Body.setAngle(body, body.angle + rotation);\n                    }\n                };\n\n                /**\n                 * Scales the body, including updating physical properties (mass, area, axes, inertia), from a world-space point (default is body centre).\n                 * @method scale\n                 * @param {body} body\n                 * @param {number} scaleX\n                 * @param {number} scaleY\n                 * @param {vector} [point]\n                 */\n                Body.scale = function (body, scaleX, scaleY, point) {\n                    var totalArea = 0,\n                        totalInertia = 0;\n\n                    point = point || body.position;\n\n                    for (var i = 0; i < body.parts.length; i++) {\n                        var part = body.parts[i];\n\n                        // scale vertices\n                        Vertices.scale(part.vertices, scaleX, scaleY, point);\n\n                        // update properties\n                        part.axes = Axes.fromVertices(part.vertices);\n                        part.area = Vertices.area(part.vertices);\n                        Body.setMass(part, body.density * part.area);\n\n                        // update inertia (requires vertices to be at origin)\n                        Vertices.translate(part.vertices, { x: -part.position.x, y: -part.position.y });\n                        Body.setInertia(part, Body._inertiaScale * Vertices.inertia(part.vertices, part.mass));\n                        Vertices.translate(part.vertices, { x: part.position.x, y: part.position.y });\n\n                        if (i > 0) {\n                            totalArea += part.area;\n                            totalInertia += part.inertia;\n                        }\n\n                        // scale position\n                        part.position.x = point.x + (part.position.x - point.x) * scaleX;\n                        part.position.y = point.y + (part.position.y - point.y) * scaleY;\n\n                        // update bounds\n                        Bounds.update(part.bounds, part.vertices, body.velocity);\n                    }\n\n                    // handle parent body\n                    if (body.parts.length > 1) {\n                        body.area = totalArea;\n\n                        if (!body.isStatic) {\n                            Body.setMass(body, body.density * totalArea);\n                            Body.setInertia(body, totalInertia);\n                        }\n                    }\n\n                    // handle circles\n                    if (body.circleRadius) {\n                        if (scaleX === scaleY) {\n                            body.circleRadius *= scaleX;\n                        } else {\n                            // body is no longer a circle\n                            body.circleRadius = null;\n                        }\n                    }\n                };\n\n                /**\n                 * Performs a simulation step for the given `body`, including updating position and angle using Verlet integration.\n                 * @method update\n                 * @param {body} body\n                 * @param {number} deltaTime\n                 * @param {number} timeScale\n                 * @param {number} correction\n                 */\n                Body.update = function (body, deltaTime, timeScale, correction) {\n                    var deltaTimeSquared = Math.pow(deltaTime * timeScale * body.timeScale, 2);\n\n                    // from the previous step\n                    var frictionAir = 1 - body.frictionAir * timeScale * body.timeScale,\n                        velocityPrevX = body.position.x - body.positionPrev.x,\n                        velocityPrevY = body.position.y - body.positionPrev.y;\n\n                    // update velocity with Verlet integration\n                    body.velocity.x = velocityPrevX * frictionAir * correction + body.force.x / body.mass * deltaTimeSquared;\n                    body.velocity.y = velocityPrevY * frictionAir * correction + body.force.y / body.mass * deltaTimeSquared;\n\n                    body.positionPrev.x = body.position.x;\n                    body.positionPrev.y = body.position.y;\n                    body.position.x += body.velocity.x;\n                    body.position.y += body.velocity.y;\n\n                    // update angular velocity with Verlet integration\n                    body.angularVelocity = (body.angle - body.anglePrev) * frictionAir * correction + body.torque / body.inertia * deltaTimeSquared;\n                    body.anglePrev = body.angle;\n                    body.angle += body.angularVelocity;\n\n                    // track speed and acceleration\n                    body.speed = Vector.magnitude(body.velocity);\n                    body.angularSpeed = Math.abs(body.angularVelocity);\n\n                    // transform the body geometry\n                    for (var i = 0; i < body.parts.length; i++) {\n                        var part = body.parts[i];\n\n                        Vertices.translate(part.vertices, body.velocity);\n\n                        if (i > 0) {\n                            part.position.x += body.velocity.x;\n                            part.position.y += body.velocity.y;\n                        }\n\n                        if (body.angularVelocity !== 0) {\n                            Vertices.rotate(part.vertices, body.angularVelocity, body.position);\n                            Axes.rotate(part.axes, body.angularVelocity);\n                            if (i > 0) {\n                                Vector.rotateAbout(part.position, body.angularVelocity, body.position, part.position);\n                            }\n                        }\n\n                        Bounds.update(part.bounds, part.vertices, body.velocity);\n                    }\n                };\n\n                /**\n                 * Applies a force to a body from a given world-space position, including resulting torque.\n                 * @method applyForce\n                 * @param {body} body\n                 * @param {vector} position\n                 * @param {vector} force\n                 */\n                Body.applyForce = function (body, position, force) {\n                    body.force.x += force.x;\n                    body.force.y += force.y;\n                    var offset = { x: position.x - body.position.x, y: position.y - body.position.y };\n                    body.torque += offset.x * force.y - offset.y * force.x;\n                };\n\n                /**\n                 * Returns the sums of the properties of all compound parts of the parent body.\n                 * @method _totalProperties\n                 * @private\n                 * @param {body} body\n                 * @return {}\n                 */\n                Body._totalProperties = function (body) {\n                    // from equations at:\n                    // https://ecourses.ou.edu/cgi-bin/ebook.cgi?doc=&topic=st&chap_sec=07.2&page=theory\n                    // http://output.to/sideway/default.asp?qno=121100087\n\n                    var properties = {\n                        mass: 0,\n                        area: 0,\n                        inertia: 0,\n                        centre: { x: 0, y: 0 }\n                    };\n\n                    // sum the properties of all compound parts of the parent body\n                    for (var i = body.parts.length === 1 ? 0 : 1; i < body.parts.length; i++) {\n                        var part = body.parts[i],\n                            mass = part.mass !== Infinity ? part.mass : 1;\n\n                        properties.mass += mass;\n                        properties.area += part.area;\n                        properties.inertia += part.inertia;\n                        properties.centre = Vector.add(properties.centre, Vector.mult(part.position, mass));\n                    }\n\n                    properties.centre = Vector.div(properties.centre, properties.mass);\n\n                    return properties;\n                };\n\n                /*\n                *\n                *  Events Documentation\n                *\n                */\n\n                /**\n                * Fired when a body starts sleeping (where `this` is the body).\n                *\n                * @event sleepStart\n                * @this {body} The body that has started sleeping\n                * @param {} event An event object\n                * @param {} event.source The source object of the event\n                * @param {} event.name The name of the event\n                */\n\n                /**\n                * Fired when a body ends sleeping (where `this` is the body).\n                *\n                * @event sleepEnd\n                * @this {body} The body that has ended sleeping\n                * @param {} event An event object\n                * @param {} event.source The source object of the event\n                * @param {} event.name The name of the event\n                */\n\n                /*\n                *\n                *  Properties Documentation\n                *\n                */\n\n                /**\n                 * An integer `Number` uniquely identifying number generated in `Body.create` by `Common.nextId`.\n                 *\n                 * @property id\n                 * @type number\n                 */\n\n                /**\n                 * A `String` denoting the type of object.\n                 *\n                 * @property type\n                 * @type string\n                 * @default \"body\"\n                 * @readOnly\n                 */\n\n                /**\n                 * An arbitrary `String` name to help the user identify and manage bodies.\n                 *\n                 * @property label\n                 * @type string\n                 * @default \"Body\"\n                 */\n\n                /**\n                 * An array of bodies that make up this body. \n                 * The first body in the array must always be a self reference to the current body instance.\n                 * All bodies in the `parts` array together form a single rigid compound body.\n                 * Parts are allowed to overlap, have gaps or holes or even form concave bodies.\n                 * Parts themselves should never be added to a `World`, only the parent body should be.\n                 * Use `Body.setParts` when setting parts to ensure correct updates of all properties.\n                 *\n                 * @property parts\n                 * @type body[]\n                 */\n\n                /**\n                 * An object reserved for storing plugin-specific properties.\n                 *\n                 * @property plugin\n                 * @type {}\n                 */\n\n                /**\n                 * A self reference if the body is _not_ a part of another body.\n                 * Otherwise this is a reference to the body that this is a part of.\n                 * See `body.parts`.\n                 *\n                 * @property parent\n                 * @type body\n                 */\n\n                /**\n                 * A `Number` specifying the angle of the body, in radians.\n                 *\n                 * @property angle\n                 * @type number\n                 * @default 0\n                 */\n\n                /**\n                 * An array of `Vector` objects that specify the convex hull of the rigid body.\n                 * These should be provided about the origin `(0, 0)`. E.g.\n                 *\n                 *     [{ x: 0, y: 0 }, { x: 25, y: 50 }, { x: 50, y: 0 }]\n                 *\n                 * When passed via `Body.create`, the vertices are translated relative to `body.position` (i.e. world-space, and constantly updated by `Body.update` during simulation).\n                 * The `Vector` objects are also augmented with additional properties required for efficient collision detection. \n                 *\n                 * Other properties such as `inertia` and `bounds` are automatically calculated from the passed vertices (unless provided via `options`).\n                 * Concave hulls are not currently supported. The module `Matter.Vertices` contains useful methods for working with vertices.\n                 *\n                 * @property vertices\n                 * @type vector[]\n                 */\n\n                /**\n                 * A `Vector` that specifies the current world-space position of the body.\n                 *\n                 * @property position\n                 * @type vector\n                 * @default { x: 0, y: 0 }\n                 */\n\n                /**\n                 * A `Vector` that specifies the force to apply in the current step. It is zeroed after every `Body.update`. See also `Body.applyForce`.\n                 *\n                 * @property force\n                 * @type vector\n                 * @default { x: 0, y: 0 }\n                 */\n\n                /**\n                 * A `Number` that specifies the torque (turning force) to apply in the current step. It is zeroed after every `Body.update`.\n                 *\n                 * @property torque\n                 * @type number\n                 * @default 0\n                 */\n\n                /**\n                 * A `Number` that _measures_ the current speed of the body after the last `Body.update`. It is read-only and always positive (it's the magnitude of `body.velocity`).\n                 *\n                 * @readOnly\n                 * @property speed\n                 * @type number\n                 * @default 0\n                 */\n\n                /**\n                 * A `Number` that _measures_ the current angular speed of the body after the last `Body.update`. It is read-only and always positive (it's the magnitude of `body.angularVelocity`).\n                 *\n                 * @readOnly\n                 * @property angularSpeed\n                 * @type number\n                 * @default 0\n                 */\n\n                /**\n                 * A `Vector` that _measures_ the current velocity of the body after the last `Body.update`. It is read-only. \n                 * If you need to modify a body's velocity directly, you should either apply a force or simply change the body's `position` (as the engine uses position-Verlet integration).\n                 *\n                 * @readOnly\n                 * @property velocity\n                 * @type vector\n                 * @default { x: 0, y: 0 }\n                 */\n\n                /**\n                 * A `Number` that _measures_ the current angular velocity of the body after the last `Body.update`. It is read-only. \n                 * If you need to modify a body's angular velocity directly, you should apply a torque or simply change the body's `angle` (as the engine uses position-Verlet integration).\n                 *\n                 * @readOnly\n                 * @property angularVelocity\n                 * @type number\n                 * @default 0\n                 */\n\n                /**\n                 * A flag that indicates whether a body is considered static. A static body can never change position or angle and is completely fixed.\n                 * If you need to set a body as static after its creation, you should use `Body.setStatic` as this requires more than just setting this flag.\n                 *\n                 * @property isStatic\n                 * @type boolean\n                 * @default false\n                 */\n\n                /**\n                 * A flag that indicates whether a body is a sensor. Sensor triggers collision events, but doesn't react with colliding body physically.\n                 *\n                 * @property isSensor\n                 * @type boolean\n                 * @default false\n                 */\n\n                /**\n                 * A flag that indicates whether the body is considered sleeping. A sleeping body acts similar to a static body, except it is only temporary and can be awoken.\n                 * If you need to set a body as sleeping, you should use `Sleeping.set` as this requires more than just setting this flag.\n                 *\n                 * @property isSleeping\n                 * @type boolean\n                 * @default false\n                 */\n\n                /**\n                 * A `Number` that _measures_ the amount of movement a body currently has (a combination of `speed` and `angularSpeed`). It is read-only and always positive.\n                 * It is used and updated by the `Matter.Sleeping` module during simulation to decide if a body has come to rest.\n                 *\n                 * @readOnly\n                 * @property motion\n                 * @type number\n                 * @default 0\n                 */\n\n                /**\n                 * A `Number` that defines the number of updates in which this body must have near-zero velocity before it is set as sleeping by the `Matter.Sleeping` module (if sleeping is enabled by the engine).\n                 *\n                 * @property sleepThreshold\n                 * @type number\n                 * @default 60\n                 */\n\n                /**\n                 * A `Number` that defines the density of the body, that is its mass per unit area.\n                 * If you pass the density via `Body.create` the `mass` property is automatically calculated for you based on the size (area) of the object.\n                 * This is generally preferable to simply setting mass and allows for more intuitive definition of materials (e.g. rock has a higher density than wood).\n                 *\n                 * @property density\n                 * @type number\n                 * @default 0.001\n                 */\n\n                /**\n                 * A `Number` that defines the mass of the body, although it may be more appropriate to specify the `density` property instead.\n                 * If you modify this value, you must also modify the `body.inverseMass` property (`1 / mass`).\n                 *\n                 * @property mass\n                 * @type number\n                 */\n\n                /**\n                 * A `Number` that defines the inverse mass of the body (`1 / mass`).\n                 * If you modify this value, you must also modify the `body.mass` property.\n                 *\n                 * @property inverseMass\n                 * @type number\n                 */\n\n                /**\n                 * A `Number` that defines the moment of inertia (i.e. second moment of area) of the body.\n                 * It is automatically calculated from the given convex hull (`vertices` array) and density in `Body.create`.\n                 * If you modify this value, you must also modify the `body.inverseInertia` property (`1 / inertia`).\n                 *\n                 * @property inertia\n                 * @type number\n                 */\n\n                /**\n                 * A `Number` that defines the inverse moment of inertia of the body (`1 / inertia`).\n                 * If you modify this value, you must also modify the `body.inertia` property.\n                 *\n                 * @property inverseInertia\n                 * @type number\n                 */\n\n                /**\n                 * A `Number` that defines the restitution (elasticity) of the body. The value is always positive and is in the range `(0, 1)`.\n                 * A value of `0` means collisions may be perfectly inelastic and no bouncing may occur. \n                 * A value of `0.8` means the body may bounce back with approximately 80% of its kinetic energy.\n                 * Note that collision response is based on _pairs_ of bodies, and that `restitution` values are _combined_ with the following formula:\n                 *\n                 *     Math.max(bodyA.restitution, bodyB.restitution)\n                 *\n                 * @property restitution\n                 * @type number\n                 * @default 0\n                 */\n\n                /**\n                 * A `Number` that defines the friction of the body. The value is always positive and is in the range `(0, 1)`.\n                 * A value of `0` means that the body may slide indefinitely.\n                 * A value of `1` means the body may come to a stop almost instantly after a force is applied.\n                 *\n                 * The effects of the value may be non-linear. \n                 * High values may be unstable depending on the body.\n                 * The engine uses a Coulomb friction model including static and kinetic friction.\n                 * Note that collision response is based on _pairs_ of bodies, and that `friction` values are _combined_ with the following formula:\n                 *\n                 *     Math.min(bodyA.friction, bodyB.friction)\n                 *\n                 * @property friction\n                 * @type number\n                 * @default 0.1\n                 */\n\n                /**\n                 * A `Number` that defines the static friction of the body (in the Coulomb friction model). \n                 * A value of `0` means the body will never 'stick' when it is nearly stationary and only dynamic `friction` is used.\n                 * The higher the value (e.g. `10`), the more force it will take to initially get the body moving when nearly stationary.\n                 * This value is multiplied with the `friction` property to make it easier to change `friction` and maintain an appropriate amount of static friction.\n                 *\n                 * @property frictionStatic\n                 * @type number\n                 * @default 0.5\n                 */\n\n                /**\n                 * A `Number` that defines the air friction of the body (air resistance). \n                 * A value of `0` means the body will never slow as it moves through space.\n                 * The higher the value, the faster a body slows when moving through space.\n                 * The effects of the value are non-linear. \n                 *\n                 * @property frictionAir\n                 * @type number\n                 * @default 0.01\n                 */\n\n                /**\n                 * An `Object` that specifies the collision filtering properties of this body.\n                 *\n                 * Collisions between two bodies will obey the following rules:\n                 * - If the two bodies have the same non-zero value of `collisionFilter.group`,\n                 *   they will always collide if the value is positive, and they will never collide\n                 *   if the value is negative.\n                 * - If the two bodies have different values of `collisionFilter.group` or if one\n                 *   (or both) of the bodies has a value of 0, then the category/mask rules apply as follows:\n                 *\n                 * Each body belongs to a collision category, given by `collisionFilter.category`. This\n                 * value is used as a bit field and the category should have only one bit set, meaning that\n                 * the value of this property is a power of two in the range [1, 2^31]. Thus, there are 32\n                 * different collision categories available.\n                 *\n                 * Each body also defines a collision bitmask, given by `collisionFilter.mask` which specifies\n                 * the categories it collides with (the value is the bitwise AND value of all these categories).\n                 *\n                 * Using the category/mask rules, two bodies `A` and `B` collide if each includes the other's\n                 * category in its mask, i.e. `(categoryA & maskB) !== 0` and `(categoryB & maskA) !== 0`\n                 * are both true.\n                 *\n                 * @property collisionFilter\n                 * @type object\n                 */\n\n                /**\n                 * An Integer `Number`, that specifies the collision group this body belongs to.\n                 * See `body.collisionFilter` for more information.\n                 *\n                 * @property collisionFilter.group\n                 * @type object\n                 * @default 0\n                 */\n\n                /**\n                 * A bit field that specifies the collision category this body belongs to.\n                 * The category value should have only one bit set, for example `0x0001`.\n                 * This means there are up to 32 unique collision categories available.\n                 * See `body.collisionFilter` for more information.\n                 *\n                 * @property collisionFilter.category\n                 * @type object\n                 * @default 1\n                 */\n\n                /**\n                 * A bit mask that specifies the collision categories this body may collide with.\n                 * See `body.collisionFilter` for more information.\n                 *\n                 * @property collisionFilter.mask\n                 * @type object\n                 * @default -1\n                 */\n\n                /**\n                 * A `Number` that specifies a tolerance on how far a body is allowed to 'sink' or rotate into other bodies.\n                 * Avoid changing this value unless you understand the purpose of `slop` in physics engines.\n                 * The default should generally suffice, although very large bodies may require larger values for stable stacking.\n                 *\n                 * @property slop\n                 * @type number\n                 * @default 0.05\n                 */\n\n                /**\n                 * A `Number` that allows per-body time scaling, e.g. a force-field where bodies inside are in slow-motion, while others are at full speed.\n                 *\n                 * @property timeScale\n                 * @type number\n                 * @default 1\n                 */\n\n                /**\n                 * An `Object` that defines the rendering properties to be consumed by the module `Matter.Render`.\n                 *\n                 * @property render\n                 * @type object\n                 */\n\n                /**\n                 * A flag that indicates if the body should be rendered.\n                 *\n                 * @property render.visible\n                 * @type boolean\n                 * @default true\n                 */\n\n                /**\n                 * Sets the opacity to use when rendering.\n                 *\n                 * @property render.opacity\n                 * @type number\n                 * @default 1\n                */\n\n                /**\n                 * An `Object` that defines the sprite properties to use when rendering, if any.\n                 *\n                 * @property render.sprite\n                 * @type object\n                 */\n\n                /**\n                 * An `String` that defines the path to the image to use as the sprite texture, if any.\n                 *\n                 * @property render.sprite.texture\n                 * @type string\n                 */\n\n                /**\n                 * A `Number` that defines the scaling in the x-axis for the sprite, if any.\n                 *\n                 * @property render.sprite.xScale\n                 * @type number\n                 * @default 1\n                 */\n\n                /**\n                 * A `Number` that defines the scaling in the y-axis for the sprite, if any.\n                 *\n                 * @property render.sprite.yScale\n                 * @type number\n                 * @default 1\n                 */\n\n                /**\n                 * A `Number` that defines the offset in the x-axis for the sprite (normalised by texture width).\n                 *\n                 * @property render.sprite.xOffset\n                 * @type number\n                 * @default 0\n                 */\n\n                /**\n                 * A `Number` that defines the offset in the y-axis for the sprite (normalised by texture height).\n                 *\n                 * @property render.sprite.yOffset\n                 * @type number\n                 * @default 0\n                 */\n\n                /**\n                 * A `Number` that defines the line width to use when rendering the body outline (if a sprite is not defined).\n                 * A value of `0` means no outline will be rendered.\n                 *\n                 * @property render.lineWidth\n                 * @type number\n                 * @default 0\n                 */\n\n                /**\n                 * A `String` that defines the fill style to use when rendering the body (if a sprite is not defined).\n                 * It is the same as when using a canvas, so it accepts CSS style property values.\n                 *\n                 * @property render.fillStyle\n                 * @type string\n                 * @default a random colour\n                 */\n\n                /**\n                 * A `String` that defines the stroke style to use when rendering the body outline (if a sprite is not defined).\n                 * It is the same as when using a canvas, so it accepts CSS style property values.\n                 *\n                 * @property render.strokeStyle\n                 * @type string\n                 * @default a random colour\n                 */\n\n                /**\n                 * An array of unique axis vectors (edge normals) used for collision detection.\n                 * These are automatically calculated from the given convex hull (`vertices` array) in `Body.create`.\n                 * They are constantly updated by `Body.update` during the simulation.\n                 *\n                 * @property axes\n                 * @type vector[]\n                 */\n\n                /**\n                 * A `Number` that _measures_ the area of the body's convex hull, calculated at creation by `Body.create`.\n                 *\n                 * @property area\n                 * @type string\n                 * @default \n                 */\n\n                /**\n                 * A `Bounds` object that defines the AABB region for the body.\n                 * It is automatically calculated from the given convex hull (`vertices` array) in `Body.create` and constantly updated by `Body.update` during simulation.\n                 *\n                 * @property bounds\n                 * @type bounds\n                 */\n            })();\n        }, { \"../core/Common\": 14, \"../core/Sleeping\": 22, \"../geometry/Axes\": 25, \"../geometry/Bounds\": 26, \"../geometry/Vector\": 28, \"../geometry/Vertices\": 29, \"../render/Render\": 31 }], 2: [function (_dereq_, module, exports) {\n            /**\n            * The `Matter.Composite` module contains methods for creating and manipulating composite bodies.\n            * A composite body is a collection of `Matter.Body`, `Matter.Constraint` and other `Matter.Composite`, therefore composites form a tree structure.\n            * It is important to use the functions in this module to modify composites, rather than directly modifying their properties.\n            * Note that the `Matter.World` object is also a type of `Matter.Composite` and as such all composite methods here can also operate on a `Matter.World`.\n            *\n            * See the included usage [examples](https://github.com/liabru/matter-js/tree/master/examples).\n            *\n            * @class Composite\n            */\n\n            var Composite = {};\n\n            module.exports = Composite;\n\n            var Events = _dereq_('../core/Events');\n            var Common = _dereq_('../core/Common');\n            var Body = _dereq_('./Body');\n\n            (function () {\n\n                /**\n                 * Creates a new composite. The options parameter is an object that specifies any properties you wish to override the defaults.\n                 * See the properites section below for detailed information on what you can pass via the `options` object.\n                 * @method create\n                 * @param {} [options]\n                 * @return {composite} A new composite\n                 */\n                Composite.create = function (options) {\n                    return Common.extend({\n                        id: Common.nextId(),\n                        type: 'composite',\n                        parent: null,\n                        isModified: false,\n                        bodies: [],\n                        constraints: [],\n                        composites: [],\n                        label: 'Composite',\n                        plugin: {}\n                    }, options);\n                };\n\n                /**\n                 * Sets the composite's `isModified` flag. \n                 * If `updateParents` is true, all parents will be set (default: false).\n                 * If `updateChildren` is true, all children will be set (default: false).\n                 * @method setModified\n                 * @param {composite} composite\n                 * @param {boolean} isModified\n                 * @param {boolean} [updateParents=false]\n                 * @param {boolean} [updateChildren=false]\n                 */\n                Composite.setModified = function (composite, isModified, updateParents, updateChildren) {\n                    composite.isModified = isModified;\n\n                    if (updateParents && composite.parent) {\n                        Composite.setModified(composite.parent, isModified, updateParents, updateChildren);\n                    }\n\n                    if (updateChildren) {\n                        for (var i = 0; i < composite.composites.length; i++) {\n                            var childComposite = composite.composites[i];\n                            Composite.setModified(childComposite, isModified, updateParents, updateChildren);\n                        }\n                    }\n                };\n\n                /**\n                 * Generic add function. Adds one or many body(s), constraint(s) or a composite(s) to the given composite.\n                 * Triggers `beforeAdd` and `afterAdd` events on the `composite`.\n                 * @method add\n                 * @param {composite} composite\n                 * @param {} object\n                 * @return {composite} The original composite with the objects added\n                 */\n                Composite.add = function (composite, object) {\n                    var objects = [].concat(object);\n\n                    Events.trigger(composite, 'beforeAdd', { object: object });\n\n                    for (var i = 0; i < objects.length; i++) {\n                        var obj = objects[i];\n\n                        switch (obj.type) {\n\n                            case 'body':\n                                // skip adding compound parts\n                                if (obj.parent !== obj) {\n                                    Common.warn('Composite.add: skipped adding a compound body part (you must add its parent instead)');\n                                    break;\n                                }\n\n                                Composite.addBody(composite, obj);\n                                break;\n                            case 'constraint':\n                                Composite.addConstraint(composite, obj);\n                                break;\n                            case 'composite':\n                                Composite.addComposite(composite, obj);\n                                break;\n                            case 'mouseConstraint':\n                                Composite.addConstraint(composite, obj.constraint);\n                                break;\n\n                        }\n                    }\n\n                    Events.trigger(composite, 'afterAdd', { object: object });\n\n                    return composite;\n                };\n\n                /**\n                 * Generic remove function. Removes one or many body(s), constraint(s) or a composite(s) to the given composite.\n                 * Optionally searching its children recursively.\n                 * Triggers `beforeRemove` and `afterRemove` events on the `composite`.\n                 * @method remove\n                 * @param {composite} composite\n                 * @param {} object\n                 * @param {boolean} [deep=false]\n                 * @return {composite} The original composite with the objects removed\n                 */\n                Composite.remove = function (composite, object, deep) {\n                    var objects = [].concat(object);\n\n                    Events.trigger(composite, 'beforeRemove', { object: object });\n\n                    for (var i = 0; i < objects.length; i++) {\n                        var obj = objects[i];\n\n                        switch (obj.type) {\n\n                            case 'body':\n                                Composite.removeBody(composite, obj, deep);\n                                break;\n                            case 'constraint':\n                                Composite.removeConstraint(composite, obj, deep);\n                                break;\n                            case 'composite':\n                                Composite.removeComposite(composite, obj, deep);\n                                break;\n                            case 'mouseConstraint':\n                                Composite.removeConstraint(composite, obj.constraint);\n                                break;\n\n                        }\n                    }\n\n                    Events.trigger(composite, 'afterRemove', { object: object });\n\n                    return composite;\n                };\n\n                /**\n                 * Adds a composite to the given composite.\n                 * @private\n                 * @method addComposite\n                 * @param {composite} compositeA\n                 * @param {composite} compositeB\n                 * @return {composite} The original compositeA with the objects from compositeB added\n                 */\n                Composite.addComposite = function (compositeA, compositeB) {\n                    compositeA.composites.push(compositeB);\n                    compositeB.parent = compositeA;\n                    Composite.setModified(compositeA, true, true, false);\n                    return compositeA;\n                };\n\n                /**\n                 * Removes a composite from the given composite, and optionally searching its children recursively.\n                 * @private\n                 * @method removeComposite\n                 * @param {composite} compositeA\n                 * @param {composite} compositeB\n                 * @param {boolean} [deep=false]\n                 * @return {composite} The original compositeA with the composite removed\n                 */\n                Composite.removeComposite = function (compositeA, compositeB, deep) {\n                    var position = Common.indexOf(compositeA.composites, compositeB);\n                    if (position !== -1) {\n                        Composite.removeCompositeAt(compositeA, position);\n                        Composite.setModified(compositeA, true, true, false);\n                    }\n\n                    if (deep) {\n                        for (var i = 0; i < compositeA.composites.length; i++) {\n                            Composite.removeComposite(compositeA.composites[i], compositeB, true);\n                        }\n                    }\n\n                    return compositeA;\n                };\n\n                /**\n                 * Removes a composite from the given composite.\n                 * @private\n                 * @method removeCompositeAt\n                 * @param {composite} composite\n                 * @param {number} position\n                 * @return {composite} The original composite with the composite removed\n                 */\n                Composite.removeCompositeAt = function (composite, position) {\n                    composite.composites.splice(position, 1);\n                    Composite.setModified(composite, true, true, false);\n                    return composite;\n                };\n\n                /**\n                 * Adds a body to the given composite.\n                 * @private\n                 * @method addBody\n                 * @param {composite} composite\n                 * @param {body} body\n                 * @return {composite} The original composite with the body added\n                 */\n                Composite.addBody = function (composite, body) {\n                    composite.bodies.push(body);\n                    Composite.setModified(composite, true, true, false);\n                    return composite;\n                };\n\n                /**\n                 * Removes a body from the given composite, and optionally searching its children recursively.\n                 * @private\n                 * @method removeBody\n                 * @param {composite} composite\n                 * @param {body} body\n                 * @param {boolean} [deep=false]\n                 * @return {composite} The original composite with the body removed\n                 */\n                Composite.removeBody = function (composite, body, deep) {\n                    var position = Common.indexOf(composite.bodies, body);\n                    if (position !== -1) {\n                        Composite.removeBodyAt(composite, position);\n                        Composite.setModified(composite, true, true, false);\n                    }\n\n                    if (deep) {\n                        for (var i = 0; i < composite.composites.length; i++) {\n                            Composite.removeBody(composite.composites[i], body, true);\n                        }\n                    }\n\n                    return composite;\n                };\n\n                /**\n                 * Removes a body from the given composite.\n                 * @private\n                 * @method removeBodyAt\n                 * @param {composite} composite\n                 * @param {number} position\n                 * @return {composite} The original composite with the body removed\n                 */\n                Composite.removeBodyAt = function (composite, position) {\n                    composite.bodies.splice(position, 1);\n                    Composite.setModified(composite, true, true, false);\n                    return composite;\n                };\n\n                /**\n                 * Adds a constraint to the given composite.\n                 * @private\n                 * @method addConstraint\n                 * @param {composite} composite\n                 * @param {constraint} constraint\n                 * @return {composite} The original composite with the constraint added\n                 */\n                Composite.addConstraint = function (composite, constraint) {\n                    composite.constraints.push(constraint);\n                    Composite.setModified(composite, true, true, false);\n                    return composite;\n                };\n\n                /**\n                 * Removes a constraint from the given composite, and optionally searching its children recursively.\n                 * @private\n                 * @method removeConstraint\n                 * @param {composite} composite\n                 * @param {constraint} constraint\n                 * @param {boolean} [deep=false]\n                 * @return {composite} The original composite with the constraint removed\n                 */\n                Composite.removeConstraint = function (composite, constraint, deep) {\n                    var position = Common.indexOf(composite.constraints, constraint);\n                    if (position !== -1) {\n                        Composite.removeConstraintAt(composite, position);\n                    }\n\n                    if (deep) {\n                        for (var i = 0; i < composite.composites.length; i++) {\n                            Composite.removeConstraint(composite.composites[i], constraint, true);\n                        }\n                    }\n\n                    return composite;\n                };\n\n                /**\n                 * Removes a body from the given composite.\n                 * @private\n                 * @method removeConstraintAt\n                 * @param {composite} composite\n                 * @param {number} position\n                 * @return {composite} The original composite with the constraint removed\n                 */\n                Composite.removeConstraintAt = function (composite, position) {\n                    composite.constraints.splice(position, 1);\n                    Composite.setModified(composite, true, true, false);\n                    return composite;\n                };\n\n                /**\n                 * Removes all bodies, constraints and composites from the given composite.\n                 * Optionally clearing its children recursively.\n                 * @method clear\n                 * @param {composite} composite\n                 * @param {boolean} keepStatic\n                 * @param {boolean} [deep=false]\n                 */\n                Composite.clear = function (composite, keepStatic, deep) {\n                    if (deep) {\n                        for (var i = 0; i < composite.composites.length; i++) {\n                            Composite.clear(composite.composites[i], keepStatic, true);\n                        }\n                    }\n\n                    if (keepStatic) {\n                        composite.bodies = composite.bodies.filter(function (body) {\n                            return body.isStatic;\n                        });\n                    } else {\n                        composite.bodies.length = 0;\n                    }\n\n                    composite.constraints.length = 0;\n                    composite.composites.length = 0;\n                    Composite.setModified(composite, true, true, false);\n\n                    return composite;\n                };\n\n                /**\n                 * Returns all bodies in the given composite, including all bodies in its children, recursively.\n                 * @method allBodies\n                 * @param {composite} composite\n                 * @return {body[]} All the bodies\n                 */\n                Composite.allBodies = function (composite) {\n                    var bodies = [].concat(composite.bodies);\n\n                    for (var i = 0; i < composite.composites.length; i++) {\n                        bodies = bodies.concat(Composite.allBodies(composite.composites[i]));\n                    }return bodies;\n                };\n\n                /**\n                 * Returns all constraints in the given composite, including all constraints in its children, recursively.\n                 * @method allConstraints\n                 * @param {composite} composite\n                 * @return {constraint[]} All the constraints\n                 */\n                Composite.allConstraints = function (composite) {\n                    var constraints = [].concat(composite.constraints);\n\n                    for (var i = 0; i < composite.composites.length; i++) {\n                        constraints = constraints.concat(Composite.allConstraints(composite.composites[i]));\n                    }return constraints;\n                };\n\n                /**\n                 * Returns all composites in the given composite, including all composites in its children, recursively.\n                 * @method allComposites\n                 * @param {composite} composite\n                 * @return {composite[]} All the composites\n                 */\n                Composite.allComposites = function (composite) {\n                    var composites = [].concat(composite.composites);\n\n                    for (var i = 0; i < composite.composites.length; i++) {\n                        composites = composites.concat(Composite.allComposites(composite.composites[i]));\n                    }return composites;\n                };\n\n                /**\n                 * Searches the composite recursively for an object matching the type and id supplied, null if not found.\n                 * @method get\n                 * @param {composite} composite\n                 * @param {number} id\n                 * @param {string} type\n                 * @return {object} The requested object, if found\n                 */\n                Composite.get = function (composite, id, type) {\n                    var objects, object;\n\n                    switch (type) {\n                        case 'body':\n                            objects = Composite.allBodies(composite);\n                            break;\n                        case 'constraint':\n                            objects = Composite.allConstraints(composite);\n                            break;\n                        case 'composite':\n                            objects = Composite.allComposites(composite).concat(composite);\n                            break;\n                    }\n\n                    if (!objects) return null;\n\n                    object = objects.filter(function (object) {\n                        return object.id.toString() === id.toString();\n                    });\n\n                    return object.length === 0 ? null : object[0];\n                };\n\n                /**\n                 * Moves the given object(s) from compositeA to compositeB (equal to a remove followed by an add).\n                 * @method move\n                 * @param {compositeA} compositeA\n                 * @param {object[]} objects\n                 * @param {compositeB} compositeB\n                 * @return {composite} Returns compositeA\n                 */\n                Composite.move = function (compositeA, objects, compositeB) {\n                    Composite.remove(compositeA, objects);\n                    Composite.add(compositeB, objects);\n                    return compositeA;\n                };\n\n                /**\n                 * Assigns new ids for all objects in the composite, recursively.\n                 * @method rebase\n                 * @param {composite} composite\n                 * @return {composite} Returns composite\n                 */\n                Composite.rebase = function (composite) {\n                    var objects = Composite.allBodies(composite).concat(Composite.allConstraints(composite)).concat(Composite.allComposites(composite));\n\n                    for (var i = 0; i < objects.length; i++) {\n                        objects[i].id = Common.nextId();\n                    }\n\n                    Composite.setModified(composite, true, true, false);\n\n                    return composite;\n                };\n\n                /**\n                 * Translates all children in the composite by a given vector relative to their current positions, \n                 * without imparting any velocity.\n                 * @method translate\n                 * @param {composite} composite\n                 * @param {vector} translation\n                 * @param {bool} [recursive=true]\n                 */\n                Composite.translate = function (composite, translation, recursive) {\n                    var bodies = recursive ? Composite.allBodies(composite) : composite.bodies;\n\n                    for (var i = 0; i < bodies.length; i++) {\n                        Body.translate(bodies[i], translation);\n                    }\n\n                    Composite.setModified(composite, true, true, false);\n\n                    return composite;\n                };\n\n                /**\n                 * Rotates all children in the composite by a given angle about the given point, without imparting any angular velocity.\n                 * @method rotate\n                 * @param {composite} composite\n                 * @param {number} rotation\n                 * @param {vector} point\n                 * @param {bool} [recursive=true]\n                 */\n                Composite.rotate = function (composite, rotation, point, recursive) {\n                    var cos = Math.cos(rotation),\n                        sin = Math.sin(rotation),\n                        bodies = recursive ? Composite.allBodies(composite) : composite.bodies;\n\n                    for (var i = 0; i < bodies.length; i++) {\n                        var body = bodies[i],\n                            dx = body.position.x - point.x,\n                            dy = body.position.y - point.y;\n\n                        Body.setPosition(body, {\n                            x: point.x + (dx * cos - dy * sin),\n                            y: point.y + (dx * sin + dy * cos)\n                        });\n\n                        Body.rotate(body, rotation);\n                    }\n\n                    Composite.setModified(composite, true, true, false);\n\n                    return composite;\n                };\n\n                /**\n                 * Scales all children in the composite, including updating physical properties (mass, area, axes, inertia), from a world-space point.\n                 * @method scale\n                 * @param {composite} composite\n                 * @param {number} scaleX\n                 * @param {number} scaleY\n                 * @param {vector} point\n                 * @param {bool} [recursive=true]\n                 */\n                Composite.scale = function (composite, scaleX, scaleY, point, recursive) {\n                    var bodies = recursive ? Composite.allBodies(composite) : composite.bodies;\n\n                    for (var i = 0; i < bodies.length; i++) {\n                        var body = bodies[i],\n                            dx = body.position.x - point.x,\n                            dy = body.position.y - point.y;\n\n                        Body.setPosition(body, {\n                            x: point.x + dx * scaleX,\n                            y: point.y + dy * scaleY\n                        });\n\n                        Body.scale(body, scaleX, scaleY);\n                    }\n\n                    Composite.setModified(composite, true, true, false);\n\n                    return composite;\n                };\n\n                /**\n                 * Returns the union of the bounds of all of the composite's bodies.\n                 * @method bounds\n                 * @param {composite} composite The composite.\n                 * @returns {bounds} The composite bounds.\n                 */\n                Composite.bounds = function (composite) {\n                    var bodies = Matter.Composite.allBodies(composite),\n                        vertices = [];\n\n                    for (var i = 0; i < bodies.length; i += 1) {\n                        var body = bodies[i];\n                        vertices.push(body.bounds.min, body.bounds.max);\n                    }\n\n                    return Matter.Bounds.create(vertices);\n                };\n\n                /*\n                *\n                *  Events Documentation\n                *\n                */\n\n                /**\n                * Fired when a call to `Composite.add` is made, before objects have been added.\n                *\n                * @event beforeAdd\n                * @param {} event An event object\n                * @param {} event.object The object(s) to be added (may be a single body, constraint, composite or a mixed array of these)\n                * @param {} event.source The source object of the event\n                * @param {} event.name The name of the event\n                */\n\n                /**\n                * Fired when a call to `Composite.add` is made, after objects have been added.\n                *\n                * @event afterAdd\n                * @param {} event An event object\n                * @param {} event.object The object(s) that have been added (may be a single body, constraint, composite or a mixed array of these)\n                * @param {} event.source The source object of the event\n                * @param {} event.name The name of the event\n                */\n\n                /**\n                * Fired when a call to `Composite.remove` is made, before objects have been removed.\n                *\n                * @event beforeRemove\n                * @param {} event An event object\n                * @param {} event.object The object(s) to be removed (may be a single body, constraint, composite or a mixed array of these)\n                * @param {} event.source The source object of the event\n                * @param {} event.name The name of the event\n                */\n\n                /**\n                * Fired when a call to `Composite.remove` is made, after objects have been removed.\n                *\n                * @event afterRemove\n                * @param {} event An event object\n                * @param {} event.object The object(s) that have been removed (may be a single body, constraint, composite or a mixed array of these)\n                * @param {} event.source The source object of the event\n                * @param {} event.name The name of the event\n                */\n\n                /*\n                *\n                *  Properties Documentation\n                *\n                */\n\n                /**\n                 * An integer `Number` uniquely identifying number generated in `Composite.create` by `Common.nextId`.\n                 *\n                 * @property id\n                 * @type number\n                 */\n\n                /**\n                 * A `String` denoting the type of object.\n                 *\n                 * @property type\n                 * @type string\n                 * @default \"composite\"\n                 * @readOnly\n                 */\n\n                /**\n                 * An arbitrary `String` name to help the user identify and manage composites.\n                 *\n                 * @property label\n                 * @type string\n                 * @default \"Composite\"\n                 */\n\n                /**\n                 * A flag that specifies whether the composite has been modified during the current step.\n                 * Most `Matter.Composite` methods will automatically set this flag to `true` to inform the engine of changes to be handled.\n                 * If you need to change it manually, you should use the `Composite.setModified` method.\n                 *\n                 * @property isModified\n                 * @type boolean\n                 * @default false\n                 */\n\n                /**\n                 * The `Composite` that is the parent of this composite. It is automatically managed by the `Matter.Composite` methods.\n                 *\n                 * @property parent\n                 * @type composite\n                 * @default null\n                 */\n\n                /**\n                 * An array of `Body` that are _direct_ children of this composite.\n                 * To add or remove bodies you should use `Composite.add` and `Composite.remove` methods rather than directly modifying this property.\n                 * If you wish to recursively find all descendants, you should use the `Composite.allBodies` method.\n                 *\n                 * @property bodies\n                 * @type body[]\n                 * @default []\n                 */\n\n                /**\n                 * An array of `Constraint` that are _direct_ children of this composite.\n                 * To add or remove constraints you should use `Composite.add` and `Composite.remove` methods rather than directly modifying this property.\n                 * If you wish to recursively find all descendants, you should use the `Composite.allConstraints` method.\n                 *\n                 * @property constraints\n                 * @type constraint[]\n                 * @default []\n                 */\n\n                /**\n                 * An array of `Composite` that are _direct_ children of this composite.\n                 * To add or remove composites you should use `Composite.add` and `Composite.remove` methods rather than directly modifying this property.\n                 * If you wish to recursively find all descendants, you should use the `Composite.allComposites` method.\n                 *\n                 * @property composites\n                 * @type composite[]\n                 * @default []\n                 */\n\n                /**\n                 * An object reserved for storing plugin-specific properties.\n                 *\n                 * @property plugin\n                 * @type {}\n                 */\n            })();\n        }, { \"../core/Common\": 14, \"../core/Events\": 16, \"./Body\": 1 }], 3: [function (_dereq_, module, exports) {\n            /**\n            * The `Matter.World` module contains methods for creating and manipulating the world composite.\n            * A `Matter.World` is a `Matter.Composite` body, which is a collection of `Matter.Body`, `Matter.Constraint` and other `Matter.Composite`.\n            * A `Matter.World` has a few additional properties including `gravity` and `bounds`.\n            * It is important to use the functions in the `Matter.Composite` module to modify the world composite, rather than directly modifying its properties.\n            * There are also a few methods here that alias those in `Matter.Composite` for easier readability.\n            *\n            * See the included usage [examples](https://github.com/liabru/matter-js/tree/master/examples).\n            *\n            * @class World\n            * @extends Composite\n            */\n\n            var World = {};\n\n            module.exports = World;\n\n            var Composite = _dereq_('./Composite');\n            var Constraint = _dereq_('../constraint/Constraint');\n            var Common = _dereq_('../core/Common');\n\n            (function () {\n\n                /**\n                 * Creates a new world composite. The options parameter is an object that specifies any properties you wish to override the defaults.\n                 * See the properties section below for detailed information on what you can pass via the `options` object.\n                 * @method create\n                 * @constructor\n                 * @param {} options\n                 * @return {world} A new world\n                 */\n                World.create = function (options) {\n                    var composite = Composite.create();\n\n                    var defaults = {\n                        label: 'World',\n                        gravity: {\n                            x: 0,\n                            y: 1,\n                            scale: 0.001\n                        },\n                        bounds: {\n                            min: { x: -Infinity, y: -Infinity },\n                            max: { x: Infinity, y: Infinity }\n                        }\n                    };\n\n                    return Common.extend(composite, defaults, options);\n                };\n\n                /*\n                *\n                *  Properties Documentation\n                *\n                */\n\n                /**\n                 * The gravity to apply on the world.\n                 *\n                 * @property gravity\n                 * @type object\n                 */\n\n                /**\n                 * The gravity x component.\n                 *\n                 * @property gravity.x\n                 * @type object\n                 * @default 0\n                 */\n\n                /**\n                 * The gravity y component.\n                 *\n                 * @property gravity.y\n                 * @type object\n                 * @default 1\n                 */\n\n                /**\n                 * The gravity scale factor.\n                 *\n                 * @property gravity.scale\n                 * @type object\n                 * @default 0.001\n                 */\n\n                /**\n                 * A `Bounds` object that defines the world bounds for collision detection.\n                 *\n                 * @property bounds\n                 * @type bounds\n                 * @default { min: { x: -Infinity, y: -Infinity }, max: { x: Infinity, y: Infinity } }\n                 */\n\n                // World is a Composite body\n                // see src/module/Outro.js for these aliases:\n\n                /**\n                 * An alias for Composite.add\n                 * @method add\n                 * @param {world} world\n                 * @param {} object\n                 * @return {composite} The original world with the objects added\n                 */\n\n                /**\n                 * An alias for Composite.remove\n                 * @method remove\n                 * @param {world} world\n                 * @param {} object\n                 * @param {boolean} [deep=false]\n                 * @return {composite} The original world with the objects removed\n                 */\n\n                /**\n                 * An alias for Composite.clear\n                 * @method clear\n                 * @param {world} world\n                 * @param {boolean} keepStatic\n                 */\n\n                /**\n                 * An alias for Composite.addComposite\n                 * @method addComposite\n                 * @param {world} world\n                 * @param {composite} composite\n                 * @return {world} The original world with the objects from composite added\n                 */\n\n                /**\n                 * An alias for Composite.addBody\n                 * @method addBody\n                 * @param {world} world\n                 * @param {body} body\n                 * @return {world} The original world with the body added\n                 */\n\n                /**\n                 * An alias for Composite.addConstraint\n                 * @method addConstraint\n                 * @param {world} world\n                 * @param {constraint} constraint\n                 * @return {world} The original world with the constraint added\n                 */\n            })();\n        }, { \"../constraint/Constraint\": 12, \"../core/Common\": 14, \"./Composite\": 2 }], 4: [function (_dereq_, module, exports) {\n            /**\n            * The `Matter.Contact` module contains methods for creating and manipulating collision contacts.\n            *\n            * @class Contact\n            */\n\n            var Contact = {};\n\n            module.exports = Contact;\n\n            (function () {\n\n                /**\n                 * Creates a new contact.\n                 * @method create\n                 * @param {vertex} vertex\n                 * @return {contact} A new contact\n                 */\n                Contact.create = function (vertex) {\n                    return {\n                        id: Contact.id(vertex),\n                        vertex: vertex,\n                        normalImpulse: 0,\n                        tangentImpulse: 0\n                    };\n                };\n\n                /**\n                 * Generates a contact id.\n                 * @method id\n                 * @param {vertex} vertex\n                 * @return {string} Unique contactID\n                 */\n                Contact.id = function (vertex) {\n                    return vertex.body.id + '_' + vertex.index;\n                };\n            })();\n        }, {}], 5: [function (_dereq_, module, exports) {\n            /**\n            * The `Matter.Detector` module contains methods for detecting collisions given a set of pairs.\n            *\n            * @class Detector\n            */\n\n            // TODO: speculative contacts\n\n            var Detector = {};\n\n            module.exports = Detector;\n\n            var SAT = _dereq_('./SAT');\n            var Pair = _dereq_('./Pair');\n            var Bounds = _dereq_('../geometry/Bounds');\n\n            (function () {\n\n                /**\n                 * Finds all collisions given a list of pairs.\n                 * @method collisions\n                 * @param {pair[]} broadphasePairs\n                 * @param {engine} engine\n                 * @return {array} collisions\n                 */\n                Detector.collisions = function (broadphasePairs, engine) {\n                    var collisions = [],\n                        pairsTable = engine.pairs.table;\n\n                    for (var i = 0; i < broadphasePairs.length; i++) {\n                        var bodyA = broadphasePairs[i][0],\n                            bodyB = broadphasePairs[i][1];\n\n                        if ((bodyA.isStatic || bodyA.isSleeping) && (bodyB.isStatic || bodyB.isSleeping)) continue;\n\n                        if (!Detector.canCollide(bodyA.collisionFilter, bodyB.collisionFilter)) continue;\n\n                        // mid phase\n                        if (Bounds.overlaps(bodyA.bounds, bodyB.bounds)) {\n                            for (var j = bodyA.parts.length > 1 ? 1 : 0; j < bodyA.parts.length; j++) {\n                                var partA = bodyA.parts[j];\n\n                                for (var k = bodyB.parts.length > 1 ? 1 : 0; k < bodyB.parts.length; k++) {\n                                    var partB = bodyB.parts[k];\n\n                                    if (partA === bodyA && partB === bodyB || Bounds.overlaps(partA.bounds, partB.bounds)) {\n                                        // find a previous collision we could reuse\n                                        var pairId = Pair.id(partA, partB),\n                                            pair = pairsTable[pairId],\n                                            previousCollision;\n\n                                        if (pair && pair.isActive) {\n                                            previousCollision = pair.collision;\n                                        } else {\n                                            previousCollision = null;\n                                        }\n\n                                        // narrow phase\n                                        var collision = SAT.collides(partA, partB, previousCollision);\n\n                                        if (collision.collided) {\n                                            collisions.push(collision);\n                                        }\n                                    }\n                                }\n                            }\n                        }\n                    }\n\n                    return collisions;\n                };\n\n                /**\n                 * Returns `true` if both supplied collision filters will allow a collision to occur.\n                 * See `body.collisionFilter` for more information.\n                 * @method canCollide\n                 * @param {} filterA\n                 * @param {} filterB\n                 * @return {bool} `true` if collision can occur\n                 */\n                Detector.canCollide = function (filterA, filterB) {\n                    if (filterA.group === filterB.group && filterA.group !== 0) return filterA.group > 0;\n\n                    return (filterA.mask & filterB.category) !== 0 && (filterB.mask & filterA.category) !== 0;\n                };\n            })();\n        }, { \"../geometry/Bounds\": 26, \"./Pair\": 7, \"./SAT\": 11 }], 6: [function (_dereq_, module, exports) {\n            /**\n            * The `Matter.Grid` module contains methods for creating and manipulating collision broadphase grid structures.\n            *\n            * @class Grid\n            */\n\n            var Grid = {};\n\n            module.exports = Grid;\n\n            var Pair = _dereq_('./Pair');\n            var Detector = _dereq_('./Detector');\n            var Common = _dereq_('../core/Common');\n\n            (function () {\n\n                /**\n                 * Creates a new grid.\n                 * @method create\n                 * @param {} options\n                 * @return {grid} A new grid\n                 */\n                Grid.create = function (options) {\n                    var defaults = {\n                        controller: Grid,\n                        detector: Detector.collisions,\n                        buckets: {},\n                        pairs: {},\n                        pairsList: [],\n                        bucketWidth: 48,\n                        bucketHeight: 48\n                    };\n\n                    return Common.extend(defaults, options);\n                };\n\n                /**\n                 * The width of a single grid bucket.\n                 *\n                 * @property bucketWidth\n                 * @type number\n                 * @default 48\n                 */\n\n                /**\n                 * The height of a single grid bucket.\n                 *\n                 * @property bucketHeight\n                 * @type number\n                 * @default 48\n                 */\n\n                /**\n                 * Updates the grid.\n                 * @method update\n                 * @param {grid} grid\n                 * @param {body[]} bodies\n                 * @param {engine} engine\n                 * @param {boolean} forceUpdate\n                 */\n                Grid.update = function (grid, bodies, engine, forceUpdate) {\n                    var i,\n                        col,\n                        row,\n                        world = engine.world,\n                        buckets = grid.buckets,\n                        bucket,\n                        bucketId,\n                        gridChanged = false;\n\n                    for (i = 0; i < bodies.length; i++) {\n                        var body = bodies[i];\n\n                        if (body.isSleeping && !forceUpdate) continue;\n\n                        // don't update out of world bodies\n                        if (body.bounds.max.x < world.bounds.min.x || body.bounds.min.x > world.bounds.max.x || body.bounds.max.y < world.bounds.min.y || body.bounds.min.y > world.bounds.max.y) continue;\n\n                        var newRegion = Grid._getRegion(grid, body);\n\n                        // if the body has changed grid region\n                        if (!body.region || newRegion.id !== body.region.id || forceUpdate) {\n\n                            if (!body.region || forceUpdate) body.region = newRegion;\n\n                            var union = Grid._regionUnion(newRegion, body.region);\n\n                            // update grid buckets affected by region change\n                            // iterate over the union of both regions\n                            for (col = union.startCol; col <= union.endCol; col++) {\n                                for (row = union.startRow; row <= union.endRow; row++) {\n                                    bucketId = Grid._getBucketId(col, row);\n                                    bucket = buckets[bucketId];\n\n                                    var isInsideNewRegion = col >= newRegion.startCol && col <= newRegion.endCol && row >= newRegion.startRow && row <= newRegion.endRow;\n\n                                    var isInsideOldRegion = col >= body.region.startCol && col <= body.region.endCol && row >= body.region.startRow && row <= body.region.endRow;\n\n                                    // remove from old region buckets\n                                    if (!isInsideNewRegion && isInsideOldRegion) {\n                                        if (isInsideOldRegion) {\n                                            if (bucket) Grid._bucketRemoveBody(grid, bucket, body);\n                                        }\n                                    }\n\n                                    // add to new region buckets\n                                    if (body.region === newRegion || isInsideNewRegion && !isInsideOldRegion || forceUpdate) {\n                                        if (!bucket) bucket = Grid._createBucket(buckets, bucketId);\n                                        Grid._bucketAddBody(grid, bucket, body);\n                                    }\n                                }\n                            }\n\n                            // set the new region\n                            body.region = newRegion;\n\n                            // flag changes so we can update pairs\n                            gridChanged = true;\n                        }\n                    }\n\n                    // update pairs list only if pairs changed (i.e. a body changed region)\n                    if (gridChanged) grid.pairsList = Grid._createActivePairsList(grid);\n                };\n\n                /**\n                 * Clears the grid.\n                 * @method clear\n                 * @param {grid} grid\n                 */\n                Grid.clear = function (grid) {\n                    grid.buckets = {};\n                    grid.pairs = {};\n                    grid.pairsList = [];\n                };\n\n                /**\n                 * Finds the union of two regions.\n                 * @method _regionUnion\n                 * @private\n                 * @param {} regionA\n                 * @param {} regionB\n                 * @return {} region\n                 */\n                Grid._regionUnion = function (regionA, regionB) {\n                    var startCol = Math.min(regionA.startCol, regionB.startCol),\n                        endCol = Math.max(regionA.endCol, regionB.endCol),\n                        startRow = Math.min(regionA.startRow, regionB.startRow),\n                        endRow = Math.max(regionA.endRow, regionB.endRow);\n\n                    return Grid._createRegion(startCol, endCol, startRow, endRow);\n                };\n\n                /**\n                 * Gets the region a given body falls in for a given grid.\n                 * @method _getRegion\n                 * @private\n                 * @param {} grid\n                 * @param {} body\n                 * @return {} region\n                 */\n                Grid._getRegion = function (grid, body) {\n                    var bounds = body.bounds,\n                        startCol = Math.floor(bounds.min.x / grid.bucketWidth),\n                        endCol = Math.floor(bounds.max.x / grid.bucketWidth),\n                        startRow = Math.floor(bounds.min.y / grid.bucketHeight),\n                        endRow = Math.floor(bounds.max.y / grid.bucketHeight);\n\n                    return Grid._createRegion(startCol, endCol, startRow, endRow);\n                };\n\n                /**\n                 * Creates a region.\n                 * @method _createRegion\n                 * @private\n                 * @param {} startCol\n                 * @param {} endCol\n                 * @param {} startRow\n                 * @param {} endRow\n                 * @return {} region\n                 */\n                Grid._createRegion = function (startCol, endCol, startRow, endRow) {\n                    return {\n                        id: startCol + ',' + endCol + ',' + startRow + ',' + endRow,\n                        startCol: startCol,\n                        endCol: endCol,\n                        startRow: startRow,\n                        endRow: endRow\n                    };\n                };\n\n                /**\n                 * Gets the bucket id at the given position.\n                 * @method _getBucketId\n                 * @private\n                 * @param {} column\n                 * @param {} row\n                 * @return {string} bucket id\n                 */\n                Grid._getBucketId = function (column, row) {\n                    return 'C' + column + 'R' + row;\n                };\n\n                /**\n                 * Creates a bucket.\n                 * @method _createBucket\n                 * @private\n                 * @param {} buckets\n                 * @param {} bucketId\n                 * @return {} bucket\n                 */\n                Grid._createBucket = function (buckets, bucketId) {\n                    var bucket = buckets[bucketId] = [];\n                    return bucket;\n                };\n\n                /**\n                 * Adds a body to a bucket.\n                 * @method _bucketAddBody\n                 * @private\n                 * @param {} grid\n                 * @param {} bucket\n                 * @param {} body\n                 */\n                Grid._bucketAddBody = function (grid, bucket, body) {\n                    // add new pairs\n                    for (var i = 0; i < bucket.length; i++) {\n                        var bodyB = bucket[i];\n\n                        if (body.id === bodyB.id || body.isStatic && bodyB.isStatic) continue;\n\n                        // keep track of the number of buckets the pair exists in\n                        // important for Grid.update to work\n                        var pairId = Pair.id(body, bodyB),\n                            pair = grid.pairs[pairId];\n\n                        if (pair) {\n                            pair[2] += 1;\n                        } else {\n                            grid.pairs[pairId] = [body, bodyB, 1];\n                        }\n                    }\n\n                    // add to bodies (after pairs, otherwise pairs with self)\n                    bucket.push(body);\n                };\n\n                /**\n                 * Removes a body from a bucket.\n                 * @method _bucketRemoveBody\n                 * @private\n                 * @param {} grid\n                 * @param {} bucket\n                 * @param {} body\n                 */\n                Grid._bucketRemoveBody = function (grid, bucket, body) {\n                    // remove from bucket\n                    bucket.splice(Common.indexOf(bucket, body), 1);\n\n                    // update pair counts\n                    for (var i = 0; i < bucket.length; i++) {\n                        // keep track of the number of buckets the pair exists in\n                        // important for _createActivePairsList to work\n                        var bodyB = bucket[i],\n                            pairId = Pair.id(body, bodyB),\n                            pair = grid.pairs[pairId];\n\n                        if (pair) pair[2] -= 1;\n                    }\n                };\n\n                /**\n                 * Generates a list of the active pairs in the grid.\n                 * @method _createActivePairsList\n                 * @private\n                 * @param {} grid\n                 * @return [] pairs\n                 */\n                Grid._createActivePairsList = function (grid) {\n                    var pairKeys,\n                        pair,\n                        pairs = [];\n\n                    // grid.pairs is used as a hashmap\n                    pairKeys = Common.keys(grid.pairs);\n\n                    // iterate over grid.pairs\n                    for (var k = 0; k < pairKeys.length; k++) {\n                        pair = grid.pairs[pairKeys[k]];\n\n                        // if pair exists in at least one bucket\n                        // it is a pair that needs further collision testing so push it\n                        if (pair[2] > 0) {\n                            pairs.push(pair);\n                        } else {\n                            delete grid.pairs[pairKeys[k]];\n                        }\n                    }\n\n                    return pairs;\n                };\n            })();\n        }, { \"../core/Common\": 14, \"./Detector\": 5, \"./Pair\": 7 }], 7: [function (_dereq_, module, exports) {\n            /**\n            * The `Matter.Pair` module contains methods for creating and manipulating collision pairs.\n            *\n            * @class Pair\n            */\n\n            var Pair = {};\n\n            module.exports = Pair;\n\n            var Contact = _dereq_('./Contact');\n\n            (function () {\n\n                /**\n                 * Creates a pair.\n                 * @method create\n                 * @param {collision} collision\n                 * @param {number} timestamp\n                 * @return {pair} A new pair\n                 */\n                Pair.create = function (collision, timestamp) {\n                    var bodyA = collision.bodyA,\n                        bodyB = collision.bodyB,\n                        parentA = collision.parentA,\n                        parentB = collision.parentB;\n\n                    var pair = {\n                        id: Pair.id(bodyA, bodyB),\n                        bodyA: bodyA,\n                        bodyB: bodyB,\n                        contacts: {},\n                        activeContacts: [],\n                        separation: 0,\n                        isActive: true,\n                        isSensor: bodyA.isSensor || bodyB.isSensor,\n                        timeCreated: timestamp,\n                        timeUpdated: timestamp,\n                        inverseMass: parentA.inverseMass + parentB.inverseMass,\n                        friction: Math.min(parentA.friction, parentB.friction),\n                        frictionStatic: Math.max(parentA.frictionStatic, parentB.frictionStatic),\n                        restitution: Math.max(parentA.restitution, parentB.restitution),\n                        slop: Math.max(parentA.slop, parentB.slop)\n                    };\n\n                    Pair.update(pair, collision, timestamp);\n\n                    return pair;\n                };\n\n                /**\n                 * Updates a pair given a collision.\n                 * @method update\n                 * @param {pair} pair\n                 * @param {collision} collision\n                 * @param {number} timestamp\n                 */\n                Pair.update = function (pair, collision, timestamp) {\n                    var contacts = pair.contacts,\n                        supports = collision.supports,\n                        activeContacts = pair.activeContacts,\n                        parentA = collision.parentA,\n                        parentB = collision.parentB;\n\n                    pair.collision = collision;\n                    pair.inverseMass = parentA.inverseMass + parentB.inverseMass;\n                    pair.friction = Math.min(parentA.friction, parentB.friction);\n                    pair.frictionStatic = Math.max(parentA.frictionStatic, parentB.frictionStatic);\n                    pair.restitution = Math.max(parentA.restitution, parentB.restitution);\n                    pair.slop = Math.max(parentA.slop, parentB.slop);\n                    activeContacts.length = 0;\n\n                    if (collision.collided) {\n                        for (var i = 0; i < supports.length; i++) {\n                            var support = supports[i],\n                                contactId = Contact.id(support),\n                                contact = contacts[contactId];\n\n                            if (contact) {\n                                activeContacts.push(contact);\n                            } else {\n                                activeContacts.push(contacts[contactId] = Contact.create(support));\n                            }\n                        }\n\n                        pair.separation = collision.depth;\n                        Pair.setActive(pair, true, timestamp);\n                    } else {\n                        if (pair.isActive === true) Pair.setActive(pair, false, timestamp);\n                    }\n                };\n\n                /**\n                 * Set a pair as active or inactive.\n                 * @method setActive\n                 * @param {pair} pair\n                 * @param {bool} isActive\n                 * @param {number} timestamp\n                 */\n                Pair.setActive = function (pair, isActive, timestamp) {\n                    if (isActive) {\n                        pair.isActive = true;\n                        pair.timeUpdated = timestamp;\n                    } else {\n                        pair.isActive = false;\n                        pair.activeContacts.length = 0;\n                    }\n                };\n\n                /**\n                 * Get the id for the given pair.\n                 * @method id\n                 * @param {body} bodyA\n                 * @param {body} bodyB\n                 * @return {string} Unique pairId\n                 */\n                Pair.id = function (bodyA, bodyB) {\n                    if (bodyA.id < bodyB.id) {\n                        return 'A' + bodyA.id + 'B' + bodyB.id;\n                    } else {\n                        return 'A' + bodyB.id + 'B' + bodyA.id;\n                    }\n                };\n            })();\n        }, { \"./Contact\": 4 }], 8: [function (_dereq_, module, exports) {\n            /**\n            * The `Matter.Pairs` module contains methods for creating and manipulating collision pair sets.\n            *\n            * @class Pairs\n            */\n\n            var Pairs = {};\n\n            module.exports = Pairs;\n\n            var Pair = _dereq_('./Pair');\n            var Common = _dereq_('../core/Common');\n\n            (function () {\n\n                Pairs._pairMaxIdleLife = 1000;\n\n                /**\n                 * Creates a new pairs structure.\n                 * @method create\n                 * @param {object} options\n                 * @return {pairs} A new pairs structure\n                 */\n                Pairs.create = function (options) {\n                    return Common.extend({\n                        table: {},\n                        list: [],\n                        collisionStart: [],\n                        collisionActive: [],\n                        collisionEnd: []\n                    }, options);\n                };\n\n                /**\n                 * Updates pairs given a list of collisions.\n                 * @method update\n                 * @param {object} pairs\n                 * @param {collision[]} collisions\n                 * @param {number} timestamp\n                 */\n                Pairs.update = function (pairs, collisions, timestamp) {\n                    var pairsList = pairs.list,\n                        pairsTable = pairs.table,\n                        collisionStart = pairs.collisionStart,\n                        collisionEnd = pairs.collisionEnd,\n                        collisionActive = pairs.collisionActive,\n                        activePairIds = [],\n                        collision,\n                        pairId,\n                        pair,\n                        i;\n\n                    // clear collision state arrays, but maintain old reference\n                    collisionStart.length = 0;\n                    collisionEnd.length = 0;\n                    collisionActive.length = 0;\n\n                    for (i = 0; i < collisions.length; i++) {\n                        collision = collisions[i];\n\n                        if (collision.collided) {\n                            pairId = Pair.id(collision.bodyA, collision.bodyB);\n                            activePairIds.push(pairId);\n\n                            pair = pairsTable[pairId];\n\n                            if (pair) {\n                                // pair already exists (but may or may not be active)\n                                if (pair.isActive) {\n                                    // pair exists and is active\n                                    collisionActive.push(pair);\n                                } else {\n                                    // pair exists but was inactive, so a collision has just started again\n                                    collisionStart.push(pair);\n                                }\n\n                                // update the pair\n                                Pair.update(pair, collision, timestamp);\n                            } else {\n                                // pair did not exist, create a new pair\n                                pair = Pair.create(collision, timestamp);\n                                pairsTable[pairId] = pair;\n\n                                // push the new pair\n                                collisionStart.push(pair);\n                                pairsList.push(pair);\n                            }\n                        }\n                    }\n\n                    // deactivate previously active pairs that are now inactive\n                    for (i = 0; i < pairsList.length; i++) {\n                        pair = pairsList[i];\n                        if (pair.isActive && Common.indexOf(activePairIds, pair.id) === -1) {\n                            Pair.setActive(pair, false, timestamp);\n                            collisionEnd.push(pair);\n                        }\n                    }\n                };\n\n                /**\n                 * Finds and removes pairs that have been inactive for a set amount of time.\n                 * @method removeOld\n                 * @param {object} pairs\n                 * @param {number} timestamp\n                 */\n                Pairs.removeOld = function (pairs, timestamp) {\n                    var pairsList = pairs.list,\n                        pairsTable = pairs.table,\n                        indexesToRemove = [],\n                        pair,\n                        collision,\n                        pairIndex,\n                        i;\n\n                    for (i = 0; i < pairsList.length; i++) {\n                        pair = pairsList[i];\n                        collision = pair.collision;\n\n                        // never remove sleeping pairs\n                        if (collision.bodyA.isSleeping || collision.bodyB.isSleeping) {\n                            pair.timeUpdated = timestamp;\n                            continue;\n                        }\n\n                        // if pair is inactive for too long, mark it to be removed\n                        if (timestamp - pair.timeUpdated > Pairs._pairMaxIdleLife) {\n                            indexesToRemove.push(i);\n                        }\n                    }\n\n                    // remove marked pairs\n                    for (i = 0; i < indexesToRemove.length; i++) {\n                        pairIndex = indexesToRemove[i] - i;\n                        pair = pairsList[pairIndex];\n                        delete pairsTable[pair.id];\n                        pairsList.splice(pairIndex, 1);\n                    }\n                };\n\n                /**\n                 * Clears the given pairs structure.\n                 * @method clear\n                 * @param {pairs} pairs\n                 * @return {pairs} pairs\n                 */\n                Pairs.clear = function (pairs) {\n                    pairs.table = {};\n                    pairs.list.length = 0;\n                    pairs.collisionStart.length = 0;\n                    pairs.collisionActive.length = 0;\n                    pairs.collisionEnd.length = 0;\n                    return pairs;\n                };\n            })();\n        }, { \"../core/Common\": 14, \"./Pair\": 7 }], 9: [function (_dereq_, module, exports) {\n            /**\n            * The `Matter.Query` module contains methods for performing collision queries.\n            *\n            * See the included usage [examples](https://github.com/liabru/matter-js/tree/master/examples).\n            *\n            * @class Query\n            */\n\n            var Query = {};\n\n            module.exports = Query;\n\n            var Vector = _dereq_('../geometry/Vector');\n            var SAT = _dereq_('./SAT');\n            var Bounds = _dereq_('../geometry/Bounds');\n            var Bodies = _dereq_('../factory/Bodies');\n            var Vertices = _dereq_('../geometry/Vertices');\n\n            (function () {\n\n                /**\n                 * Returns a list of collisions between `body` and `bodies`.\n                 * @method collides\n                 * @param {body} body\n                 * @param {body[]} bodies\n                 * @return {object[]} Collisions\n                 */\n                Query.collides = function (body, bodies) {\n                    var collisions = [];\n\n                    for (var i = 0; i < bodies.length; i++) {\n                        var bodyA = bodies[i];\n\n                        if (Bounds.overlaps(bodyA.bounds, body.bounds)) {\n                            for (var j = bodyA.parts.length === 1 ? 0 : 1; j < bodyA.parts.length; j++) {\n                                var part = bodyA.parts[j];\n\n                                if (Bounds.overlaps(part.bounds, body.bounds)) {\n                                    var collision = SAT.collides(part, body);\n\n                                    if (collision.collided) {\n                                        collisions.push(collision);\n                                        break;\n                                    }\n                                }\n                            }\n                        }\n                    }\n\n                    return collisions;\n                };\n\n                /**\n                 * Casts a ray segment against a set of bodies and returns all collisions, ray width is optional. Intersection points are not provided.\n                 * @method ray\n                 * @param {body[]} bodies\n                 * @param {vector} startPoint\n                 * @param {vector} endPoint\n                 * @param {number} [rayWidth]\n                 * @return {object[]} Collisions\n                 */\n                Query.ray = function (bodies, startPoint, endPoint, rayWidth) {\n                    rayWidth = rayWidth || 1e-100;\n\n                    var rayAngle = Vector.angle(startPoint, endPoint),\n                        rayLength = Vector.magnitude(Vector.sub(startPoint, endPoint)),\n                        rayX = (endPoint.x + startPoint.x) * 0.5,\n                        rayY = (endPoint.y + startPoint.y) * 0.5,\n                        ray = Bodies.rectangle(rayX, rayY, rayLength, rayWidth, { angle: rayAngle }),\n                        collisions = Query.collides(ray, bodies);\n\n                    for (var i = 0; i < collisions.length; i += 1) {\n                        var collision = collisions[i];\n                        collision.body = collision.bodyB = collision.bodyA;\n                    }\n\n                    return collisions;\n                };\n\n                /**\n                 * Returns all bodies whose bounds are inside (or outside if set) the given set of bounds, from the given set of bodies.\n                 * @method region\n                 * @param {body[]} bodies\n                 * @param {bounds} bounds\n                 * @param {bool} [outside=false]\n                 * @return {body[]} The bodies matching the query\n                 */\n                Query.region = function (bodies, bounds, outside) {\n                    var result = [];\n\n                    for (var i = 0; i < bodies.length; i++) {\n                        var body = bodies[i],\n                            overlaps = Bounds.overlaps(body.bounds, bounds);\n                        if (overlaps && !outside || !overlaps && outside) result.push(body);\n                    }\n\n                    return result;\n                };\n\n                /**\n                 * Returns all bodies whose vertices contain the given point, from the given set of bodies.\n                 * @method point\n                 * @param {body[]} bodies\n                 * @param {vector} point\n                 * @return {body[]} The bodies matching the query\n                 */\n                Query.point = function (bodies, point) {\n                    var result = [];\n\n                    for (var i = 0; i < bodies.length; i++) {\n                        var body = bodies[i];\n\n                        if (Bounds.contains(body.bounds, point)) {\n                            for (var j = body.parts.length === 1 ? 0 : 1; j < body.parts.length; j++) {\n                                var part = body.parts[j];\n\n                                if (Bounds.contains(part.bounds, point) && Vertices.contains(part.vertices, point)) {\n                                    result.push(body);\n                                    break;\n                                }\n                            }\n                        }\n                    }\n\n                    return result;\n                };\n            })();\n        }, { \"../factory/Bodies\": 23, \"../geometry/Bounds\": 26, \"../geometry/Vector\": 28, \"../geometry/Vertices\": 29, \"./SAT\": 11 }], 10: [function (_dereq_, module, exports) {\n            /**\n            * The `Matter.Resolver` module contains methods for resolving collision pairs.\n            *\n            * @class Resolver\n            */\n\n            var Resolver = {};\n\n            module.exports = Resolver;\n\n            var Vertices = _dereq_('../geometry/Vertices');\n            var Vector = _dereq_('../geometry/Vector');\n            var Common = _dereq_('../core/Common');\n            var Bounds = _dereq_('../geometry/Bounds');\n\n            (function () {\n\n                Resolver._restingThresh = 4;\n                Resolver._restingThreshTangent = 6;\n                Resolver._positionDampen = 0.9;\n                Resolver._positionWarming = 0.8;\n                Resolver._frictionNormalMultiplier = 5;\n\n                /**\n                 * Prepare pairs for position solving.\n                 * @method preSolvePosition\n                 * @param {pair[]} pairs\n                 */\n                Resolver.preSolvePosition = function (pairs) {\n                    var i, pair, activeCount;\n\n                    // find total contacts on each body\n                    for (i = 0; i < pairs.length; i++) {\n                        pair = pairs[i];\n\n                        if (!pair.isActive) continue;\n\n                        activeCount = pair.activeContacts.length;\n                        pair.collision.parentA.totalContacts += activeCount;\n                        pair.collision.parentB.totalContacts += activeCount;\n                    }\n                };\n\n                /**\n                 * Find a solution for pair positions.\n                 * @method solvePosition\n                 * @param {pair[]} pairs\n                 * @param {number} timeScale\n                 */\n                Resolver.solvePosition = function (pairs, timeScale) {\n                    var i,\n                        pair,\n                        collision,\n                        bodyA,\n                        bodyB,\n                        normal,\n                        bodyBtoA,\n                        contactShare,\n                        positionImpulse,\n                        contactCount = {},\n                        tempA = Vector._temp[0],\n                        tempB = Vector._temp[1],\n                        tempC = Vector._temp[2],\n                        tempD = Vector._temp[3];\n\n                    // find impulses required to resolve penetration\n                    for (i = 0; i < pairs.length; i++) {\n                        pair = pairs[i];\n\n                        if (!pair.isActive || pair.isSensor) continue;\n\n                        collision = pair.collision;\n                        bodyA = collision.parentA;\n                        bodyB = collision.parentB;\n                        normal = collision.normal;\n\n                        // get current separation between body edges involved in collision\n                        bodyBtoA = Vector.sub(Vector.add(bodyB.positionImpulse, bodyB.position, tempA), Vector.add(bodyA.positionImpulse, Vector.sub(bodyB.position, collision.penetration, tempB), tempC), tempD);\n\n                        pair.separation = Vector.dot(normal, bodyBtoA);\n                    }\n\n                    for (i = 0; i < pairs.length; i++) {\n                        pair = pairs[i];\n\n                        if (!pair.isActive || pair.isSensor) continue;\n\n                        collision = pair.collision;\n                        bodyA = collision.parentA;\n                        bodyB = collision.parentB;\n                        normal = collision.normal;\n                        positionImpulse = (pair.separation - pair.slop) * timeScale;\n\n                        if (bodyA.isStatic || bodyB.isStatic) positionImpulse *= 2;\n\n                        if (!(bodyA.isStatic || bodyA.isSleeping)) {\n                            contactShare = Resolver._positionDampen / bodyA.totalContacts;\n                            bodyA.positionImpulse.x += normal.x * positionImpulse * contactShare;\n                            bodyA.positionImpulse.y += normal.y * positionImpulse * contactShare;\n                        }\n\n                        if (!(bodyB.isStatic || bodyB.isSleeping)) {\n                            contactShare = Resolver._positionDampen / bodyB.totalContacts;\n                            bodyB.positionImpulse.x -= normal.x * positionImpulse * contactShare;\n                            bodyB.positionImpulse.y -= normal.y * positionImpulse * contactShare;\n                        }\n                    }\n                };\n\n                /**\n                 * Apply position resolution.\n                 * @method postSolvePosition\n                 * @param {body[]} bodies\n                 */\n                Resolver.postSolvePosition = function (bodies) {\n                    for (var i = 0; i < bodies.length; i++) {\n                        var body = bodies[i];\n\n                        // reset contact count\n                        body.totalContacts = 0;\n\n                        if (body.positionImpulse.x !== 0 || body.positionImpulse.y !== 0) {\n                            // update body geometry\n                            for (var j = 0; j < body.parts.length; j++) {\n                                var part = body.parts[j];\n                                Vertices.translate(part.vertices, body.positionImpulse);\n                                Bounds.update(part.bounds, part.vertices, body.velocity);\n                                part.position.x += body.positionImpulse.x;\n                                part.position.y += body.positionImpulse.y;\n                            }\n\n                            // move the body without changing velocity\n                            body.positionPrev.x += body.positionImpulse.x;\n                            body.positionPrev.y += body.positionImpulse.y;\n\n                            if (Vector.dot(body.positionImpulse, body.velocity) < 0) {\n                                // reset cached impulse if the body has velocity along it\n                                body.positionImpulse.x = 0;\n                                body.positionImpulse.y = 0;\n                            } else {\n                                // warm the next iteration\n                                body.positionImpulse.x *= Resolver._positionWarming;\n                                body.positionImpulse.y *= Resolver._positionWarming;\n                            }\n                        }\n                    }\n                };\n\n                /**\n                 * Prepare pairs for velocity solving.\n                 * @method preSolveVelocity\n                 * @param {pair[]} pairs\n                 */\n                Resolver.preSolveVelocity = function (pairs) {\n                    var i,\n                        j,\n                        pair,\n                        contacts,\n                        collision,\n                        bodyA,\n                        bodyB,\n                        normal,\n                        tangent,\n                        contact,\n                        contactVertex,\n                        normalImpulse,\n                        tangentImpulse,\n                        offset,\n                        impulse = Vector._temp[0],\n                        tempA = Vector._temp[1];\n\n                    for (i = 0; i < pairs.length; i++) {\n                        pair = pairs[i];\n\n                        if (!pair.isActive || pair.isSensor) continue;\n\n                        contacts = pair.activeContacts;\n                        collision = pair.collision;\n                        bodyA = collision.parentA;\n                        bodyB = collision.parentB;\n                        normal = collision.normal;\n                        tangent = collision.tangent;\n\n                        // resolve each contact\n                        for (j = 0; j < contacts.length; j++) {\n                            contact = contacts[j];\n                            contactVertex = contact.vertex;\n                            normalImpulse = contact.normalImpulse;\n                            tangentImpulse = contact.tangentImpulse;\n\n                            if (normalImpulse !== 0 || tangentImpulse !== 0) {\n                                // total impulse from contact\n                                impulse.x = normal.x * normalImpulse + tangent.x * tangentImpulse;\n                                impulse.y = normal.y * normalImpulse + tangent.y * tangentImpulse;\n\n                                // apply impulse from contact\n                                if (!(bodyA.isStatic || bodyA.isSleeping)) {\n                                    offset = Vector.sub(contactVertex, bodyA.position, tempA);\n                                    bodyA.positionPrev.x += impulse.x * bodyA.inverseMass;\n                                    bodyA.positionPrev.y += impulse.y * bodyA.inverseMass;\n                                    bodyA.anglePrev += Vector.cross(offset, impulse) * bodyA.inverseInertia;\n                                }\n\n                                if (!(bodyB.isStatic || bodyB.isSleeping)) {\n                                    offset = Vector.sub(contactVertex, bodyB.position, tempA);\n                                    bodyB.positionPrev.x -= impulse.x * bodyB.inverseMass;\n                                    bodyB.positionPrev.y -= impulse.y * bodyB.inverseMass;\n                                    bodyB.anglePrev -= Vector.cross(offset, impulse) * bodyB.inverseInertia;\n                                }\n                            }\n                        }\n                    }\n                };\n\n                /**\n                 * Find a solution for pair velocities.\n                 * @method solveVelocity\n                 * @param {pair[]} pairs\n                 * @param {number} timeScale\n                 */\n                Resolver.solveVelocity = function (pairs, timeScale) {\n                    var timeScaleSquared = timeScale * timeScale,\n                        impulse = Vector._temp[0],\n                        tempA = Vector._temp[1],\n                        tempB = Vector._temp[2],\n                        tempC = Vector._temp[3],\n                        tempD = Vector._temp[4],\n                        tempE = Vector._temp[5];\n\n                    for (var i = 0; i < pairs.length; i++) {\n                        var pair = pairs[i];\n\n                        if (!pair.isActive || pair.isSensor) continue;\n\n                        var collision = pair.collision,\n                            bodyA = collision.parentA,\n                            bodyB = collision.parentB,\n                            normal = collision.normal,\n                            tangent = collision.tangent,\n                            contacts = pair.activeContacts,\n                            contactShare = 1 / contacts.length;\n\n                        // update body velocities\n                        bodyA.velocity.x = bodyA.position.x - bodyA.positionPrev.x;\n                        bodyA.velocity.y = bodyA.position.y - bodyA.positionPrev.y;\n                        bodyB.velocity.x = bodyB.position.x - bodyB.positionPrev.x;\n                        bodyB.velocity.y = bodyB.position.y - bodyB.positionPrev.y;\n                        bodyA.angularVelocity = bodyA.angle - bodyA.anglePrev;\n                        bodyB.angularVelocity = bodyB.angle - bodyB.anglePrev;\n\n                        // resolve each contact\n                        for (var j = 0; j < contacts.length; j++) {\n                            var contact = contacts[j],\n                                contactVertex = contact.vertex,\n                                offsetA = Vector.sub(contactVertex, bodyA.position, tempA),\n                                offsetB = Vector.sub(contactVertex, bodyB.position, tempB),\n                                velocityPointA = Vector.add(bodyA.velocity, Vector.mult(Vector.perp(offsetA), bodyA.angularVelocity), tempC),\n                                velocityPointB = Vector.add(bodyB.velocity, Vector.mult(Vector.perp(offsetB), bodyB.angularVelocity), tempD),\n                                relativeVelocity = Vector.sub(velocityPointA, velocityPointB, tempE),\n                                normalVelocity = Vector.dot(normal, relativeVelocity);\n\n                            var tangentVelocity = Vector.dot(tangent, relativeVelocity),\n                                tangentSpeed = Math.abs(tangentVelocity),\n                                tangentVelocityDirection = Common.sign(tangentVelocity);\n\n                            // raw impulses\n                            var normalImpulse = (1 + pair.restitution) * normalVelocity,\n                                normalForce = Common.clamp(pair.separation + normalVelocity, 0, 1) * Resolver._frictionNormalMultiplier;\n\n                            // coulomb friction\n                            var tangentImpulse = tangentVelocity,\n                                maxFriction = Infinity;\n\n                            if (tangentSpeed > pair.friction * pair.frictionStatic * normalForce * timeScaleSquared) {\n                                maxFriction = tangentSpeed;\n                                tangentImpulse = Common.clamp(pair.friction * tangentVelocityDirection * timeScaleSquared, -maxFriction, maxFriction);\n                            }\n\n                            // modify impulses accounting for mass, inertia and offset\n                            var oAcN = Vector.cross(offsetA, normal),\n                                oBcN = Vector.cross(offsetB, normal),\n                                share = contactShare / (bodyA.inverseMass + bodyB.inverseMass + bodyA.inverseInertia * oAcN * oAcN + bodyB.inverseInertia * oBcN * oBcN);\n\n                            normalImpulse *= share;\n                            tangentImpulse *= share;\n\n                            // handle high velocity and resting collisions separately\n                            if (normalVelocity < 0 && normalVelocity * normalVelocity > Resolver._restingThresh * timeScaleSquared) {\n                                // high normal velocity so clear cached contact normal impulse\n                                contact.normalImpulse = 0;\n                            } else {\n                                // solve resting collision constraints using Erin Catto's method (GDC08)\n                                // impulse constraint tends to 0\n                                var contactNormalImpulse = contact.normalImpulse;\n                                contact.normalImpulse = Math.min(contact.normalImpulse + normalImpulse, 0);\n                                normalImpulse = contact.normalImpulse - contactNormalImpulse;\n                            }\n\n                            // handle high velocity and resting collisions separately\n                            if (tangentVelocity * tangentVelocity > Resolver._restingThreshTangent * timeScaleSquared) {\n                                // high tangent velocity so clear cached contact tangent impulse\n                                contact.tangentImpulse = 0;\n                            } else {\n                                // solve resting collision constraints using Erin Catto's method (GDC08)\n                                // tangent impulse tends to -tangentSpeed or +tangentSpeed\n                                var contactTangentImpulse = contact.tangentImpulse;\n                                contact.tangentImpulse = Common.clamp(contact.tangentImpulse + tangentImpulse, -maxFriction, maxFriction);\n                                tangentImpulse = contact.tangentImpulse - contactTangentImpulse;\n                            }\n\n                            // total impulse from contact\n                            impulse.x = normal.x * normalImpulse + tangent.x * tangentImpulse;\n                            impulse.y = normal.y * normalImpulse + tangent.y * tangentImpulse;\n\n                            // apply impulse from contact\n                            if (!(bodyA.isStatic || bodyA.isSleeping)) {\n                                bodyA.positionPrev.x += impulse.x * bodyA.inverseMass;\n                                bodyA.positionPrev.y += impulse.y * bodyA.inverseMass;\n                                bodyA.anglePrev += Vector.cross(offsetA, impulse) * bodyA.inverseInertia;\n                            }\n\n                            if (!(bodyB.isStatic || bodyB.isSleeping)) {\n                                bodyB.positionPrev.x -= impulse.x * bodyB.inverseMass;\n                                bodyB.positionPrev.y -= impulse.y * bodyB.inverseMass;\n                                bodyB.anglePrev -= Vector.cross(offsetB, impulse) * bodyB.inverseInertia;\n                            }\n                        }\n                    }\n                };\n            })();\n        }, { \"../core/Common\": 14, \"../geometry/Bounds\": 26, \"../geometry/Vector\": 28, \"../geometry/Vertices\": 29 }], 11: [function (_dereq_, module, exports) {\n            /**\n            * The `Matter.SAT` module contains methods for detecting collisions using the Separating Axis Theorem.\n            *\n            * @class SAT\n            */\n\n            // TODO: true circles and curves\n\n            var SAT = {};\n\n            module.exports = SAT;\n\n            var Vertices = _dereq_('../geometry/Vertices');\n            var Vector = _dereq_('../geometry/Vector');\n\n            (function () {\n\n                /**\n                 * Detect collision between two bodies using the Separating Axis Theorem.\n                 * @method collides\n                 * @param {body} bodyA\n                 * @param {body} bodyB\n                 * @param {collision} previousCollision\n                 * @return {collision} collision\n                 */\n                SAT.collides = function (bodyA, bodyB, previousCollision) {\n                    var overlapAB,\n                        overlapBA,\n                        minOverlap,\n                        collision,\n                        canReusePrevCol = false;\n\n                    if (previousCollision) {\n                        // estimate total motion\n                        var parentA = bodyA.parent,\n                            parentB = bodyB.parent,\n                            motion = parentA.speed * parentA.speed + parentA.angularSpeed * parentA.angularSpeed + parentB.speed * parentB.speed + parentB.angularSpeed * parentB.angularSpeed;\n\n                        // we may be able to (partially) reuse collision result \n                        // but only safe if collision was resting\n                        canReusePrevCol = previousCollision && previousCollision.collided && motion < 0.2;\n\n                        // reuse collision object\n                        collision = previousCollision;\n                    } else {\n                        collision = { collided: false, bodyA: bodyA, bodyB: bodyB };\n                    }\n\n                    if (previousCollision && canReusePrevCol) {\n                        // if we can reuse the collision result\n                        // we only need to test the previously found axis\n                        var axisBodyA = collision.axisBody,\n                            axisBodyB = axisBodyA === bodyA ? bodyB : bodyA,\n                            axes = [axisBodyA.axes[previousCollision.axisNumber]];\n\n                        minOverlap = SAT._overlapAxes(axisBodyA.vertices, axisBodyB.vertices, axes);\n                        collision.reused = true;\n\n                        if (minOverlap.overlap <= 0) {\n                            collision.collided = false;\n                            return collision;\n                        }\n                    } else {\n                        // if we can't reuse a result, perform a full SAT test\n\n                        overlapAB = SAT._overlapAxes(bodyA.vertices, bodyB.vertices, bodyA.axes);\n\n                        if (overlapAB.overlap <= 0) {\n                            collision.collided = false;\n                            return collision;\n                        }\n\n                        overlapBA = SAT._overlapAxes(bodyB.vertices, bodyA.vertices, bodyB.axes);\n\n                        if (overlapBA.overlap <= 0) {\n                            collision.collided = false;\n                            return collision;\n                        }\n\n                        if (overlapAB.overlap < overlapBA.overlap) {\n                            minOverlap = overlapAB;\n                            collision.axisBody = bodyA;\n                        } else {\n                            minOverlap = overlapBA;\n                            collision.axisBody = bodyB;\n                        }\n\n                        // important for reuse later\n                        collision.axisNumber = minOverlap.axisNumber;\n                    }\n\n                    collision.bodyA = bodyA.id < bodyB.id ? bodyA : bodyB;\n                    collision.bodyB = bodyA.id < bodyB.id ? bodyB : bodyA;\n                    collision.collided = true;\n                    collision.depth = minOverlap.overlap;\n                    collision.parentA = collision.bodyA.parent;\n                    collision.parentB = collision.bodyB.parent;\n\n                    bodyA = collision.bodyA;\n                    bodyB = collision.bodyB;\n\n                    // ensure normal is facing away from bodyA\n                    if (Vector.dot(minOverlap.axis, Vector.sub(bodyB.position, bodyA.position)) < 0) {\n                        collision.normal = {\n                            x: minOverlap.axis.x,\n                            y: minOverlap.axis.y\n                        };\n                    } else {\n                        collision.normal = {\n                            x: -minOverlap.axis.x,\n                            y: -minOverlap.axis.y\n                        };\n                    }\n\n                    collision.tangent = Vector.perp(collision.normal);\n\n                    collision.penetration = collision.penetration || {};\n                    collision.penetration.x = collision.normal.x * collision.depth;\n                    collision.penetration.y = collision.normal.y * collision.depth;\n\n                    // find support points, there is always either exactly one or two\n                    var verticesB = SAT._findSupports(bodyA, bodyB, collision.normal),\n                        supports = [];\n\n                    // find the supports from bodyB that are inside bodyA\n                    if (Vertices.contains(bodyA.vertices, verticesB[0])) supports.push(verticesB[0]);\n\n                    if (Vertices.contains(bodyA.vertices, verticesB[1])) supports.push(verticesB[1]);\n\n                    // find the supports from bodyA that are inside bodyB\n                    if (supports.length < 2) {\n                        var verticesA = SAT._findSupports(bodyB, bodyA, Vector.neg(collision.normal));\n\n                        if (Vertices.contains(bodyB.vertices, verticesA[0])) supports.push(verticesA[0]);\n\n                        if (supports.length < 2 && Vertices.contains(bodyB.vertices, verticesA[1])) supports.push(verticesA[1]);\n                    }\n\n                    // account for the edge case of overlapping but no vertex containment\n                    if (supports.length < 1) supports = [verticesB[0]];\n\n                    collision.supports = supports;\n\n                    return collision;\n                };\n\n                /**\n                 * Find the overlap between two sets of vertices.\n                 * @method _overlapAxes\n                 * @private\n                 * @param {} verticesA\n                 * @param {} verticesB\n                 * @param {} axes\n                 * @return result\n                 */\n                SAT._overlapAxes = function (verticesA, verticesB, axes) {\n                    var projectionA = Vector._temp[0],\n                        projectionB = Vector._temp[1],\n                        result = { overlap: Number.MAX_VALUE },\n                        overlap,\n                        axis;\n\n                    for (var i = 0; i < axes.length; i++) {\n                        axis = axes[i];\n\n                        SAT._projectToAxis(projectionA, verticesA, axis);\n                        SAT._projectToAxis(projectionB, verticesB, axis);\n\n                        overlap = Math.min(projectionA.max - projectionB.min, projectionB.max - projectionA.min);\n\n                        if (overlap <= 0) {\n                            result.overlap = overlap;\n                            return result;\n                        }\n\n                        if (overlap < result.overlap) {\n                            result.overlap = overlap;\n                            result.axis = axis;\n                            result.axisNumber = i;\n                        }\n                    }\n\n                    return result;\n                };\n\n                /**\n                 * Projects vertices on an axis and returns an interval.\n                 * @method _projectToAxis\n                 * @private\n                 * @param {} projection\n                 * @param {} vertices\n                 * @param {} axis\n                 */\n                SAT._projectToAxis = function (projection, vertices, axis) {\n                    var min = Vector.dot(vertices[0], axis),\n                        max = min;\n\n                    for (var i = 1; i < vertices.length; i += 1) {\n                        var dot = Vector.dot(vertices[i], axis);\n\n                        if (dot > max) {\n                            max = dot;\n                        } else if (dot < min) {\n                            min = dot;\n                        }\n                    }\n\n                    projection.min = min;\n                    projection.max = max;\n                };\n\n                /**\n                 * Finds supporting vertices given two bodies along a given direction using hill-climbing.\n                 * @method _findSupports\n                 * @private\n                 * @param {} bodyA\n                 * @param {} bodyB\n                 * @param {} normal\n                 * @return [vector]\n                 */\n                SAT._findSupports = function (bodyA, bodyB, normal) {\n                    var nearestDistance = Number.MAX_VALUE,\n                        vertexToBody = Vector._temp[0],\n                        vertices = bodyB.vertices,\n                        bodyAPosition = bodyA.position,\n                        distance,\n                        vertex,\n                        vertexA,\n                        vertexB;\n\n                    // find closest vertex on bodyB\n                    for (var i = 0; i < vertices.length; i++) {\n                        vertex = vertices[i];\n                        vertexToBody.x = vertex.x - bodyAPosition.x;\n                        vertexToBody.y = vertex.y - bodyAPosition.y;\n                        distance = -Vector.dot(normal, vertexToBody);\n\n                        if (distance < nearestDistance) {\n                            nearestDistance = distance;\n                            vertexA = vertex;\n                        }\n                    }\n\n                    // find next closest vertex using the two connected to it\n                    var prevIndex = vertexA.index - 1 >= 0 ? vertexA.index - 1 : vertices.length - 1;\n                    vertex = vertices[prevIndex];\n                    vertexToBody.x = vertex.x - bodyAPosition.x;\n                    vertexToBody.y = vertex.y - bodyAPosition.y;\n                    nearestDistance = -Vector.dot(normal, vertexToBody);\n                    vertexB = vertex;\n\n                    var nextIndex = (vertexA.index + 1) % vertices.length;\n                    vertex = vertices[nextIndex];\n                    vertexToBody.x = vertex.x - bodyAPosition.x;\n                    vertexToBody.y = vertex.y - bodyAPosition.y;\n                    distance = -Vector.dot(normal, vertexToBody);\n                    if (distance < nearestDistance) {\n                        vertexB = vertex;\n                    }\n\n                    return [vertexA, vertexB];\n                };\n            })();\n        }, { \"../geometry/Vector\": 28, \"../geometry/Vertices\": 29 }], 12: [function (_dereq_, module, exports) {\n            /**\n            * The `Matter.Constraint` module contains methods for creating and manipulating constraints.\n            * Constraints are used for specifying that a fixed distance must be maintained between two bodies (or a body and a fixed world-space position).\n            * The stiffness of constraints can be modified to create springs or elastic.\n            *\n            * See the included usage [examples](https://github.com/liabru/matter-js/tree/master/examples).\n            *\n            * @class Constraint\n            */\n\n            var Constraint = {};\n\n            module.exports = Constraint;\n\n            var Vertices = _dereq_('../geometry/Vertices');\n            var Vector = _dereq_('../geometry/Vector');\n            var Sleeping = _dereq_('../core/Sleeping');\n            var Bounds = _dereq_('../geometry/Bounds');\n            var Axes = _dereq_('../geometry/Axes');\n            var Common = _dereq_('../core/Common');\n\n            (function () {\n\n                Constraint._warming = 0.4;\n                Constraint._torqueDampen = 1;\n                Constraint._minLength = 0.000001;\n\n                /**\n                 * Creates a new constraint.\n                 * All properties have default values, and many are pre-calculated automatically based on other properties.\n                 * To simulate a revolute constraint (or pin joint) set `length: 0` and a high `stiffness` value (e.g. `0.7` or above).\n                 * If the constraint is unstable, try lowering the `stiffness` value and / or increasing `engine.constraintIterations`.\n                 * For compound bodies, constraints must be applied to the parent body (not one of its parts).\n                 * See the properties section below for detailed information on what you can pass via the `options` object.\n                 * @method create\n                 * @param {} options\n                 * @return {constraint} constraint\n                 */\n                Constraint.create = function (options) {\n                    var constraint = options;\n\n                    // if bodies defined but no points, use body centre\n                    if (constraint.bodyA && !constraint.pointA) constraint.pointA = { x: 0, y: 0 };\n                    if (constraint.bodyB && !constraint.pointB) constraint.pointB = { x: 0, y: 0 };\n\n                    // calculate static length using initial world space points\n                    var initialPointA = constraint.bodyA ? Vector.add(constraint.bodyA.position, constraint.pointA) : constraint.pointA,\n                        initialPointB = constraint.bodyB ? Vector.add(constraint.bodyB.position, constraint.pointB) : constraint.pointB,\n                        length = Vector.magnitude(Vector.sub(initialPointA, initialPointB));\n\n                    constraint.length = typeof constraint.length !== 'undefined' ? constraint.length : length;\n\n                    // option defaults\n                    constraint.id = constraint.id || Common.nextId();\n                    constraint.label = constraint.label || 'Constraint';\n                    constraint.type = 'constraint';\n                    constraint.stiffness = constraint.stiffness || (constraint.length > 0 ? 1 : 0.7);\n                    constraint.damping = constraint.damping || 0;\n                    constraint.angularStiffness = constraint.angularStiffness || 0;\n                    constraint.angleA = constraint.bodyA ? constraint.bodyA.angle : constraint.angleA;\n                    constraint.angleB = constraint.bodyB ? constraint.bodyB.angle : constraint.angleB;\n                    constraint.plugin = {};\n\n                    // render\n                    var render = {\n                        visible: true,\n                        lineWidth: 2,\n                        strokeStyle: '#ffffff',\n                        type: 'line',\n                        anchors: true\n                    };\n\n                    if (constraint.length === 0 && constraint.stiffness > 0.1) {\n                        render.type = 'pin';\n                        render.anchors = false;\n                    } else if (constraint.stiffness < 0.9) {\n                        render.type = 'spring';\n                    }\n\n                    constraint.render = Common.extend(render, constraint.render);\n\n                    return constraint;\n                };\n\n                /**\n                 * Prepares for solving by constraint warming.\n                 * @private\n                 * @method preSolveAll\n                 * @param {body[]} bodies\n                 */\n                Constraint.preSolveAll = function (bodies) {\n                    for (var i = 0; i < bodies.length; i += 1) {\n                        var body = bodies[i],\n                            impulse = body.constraintImpulse;\n\n                        if (body.isStatic || impulse.x === 0 && impulse.y === 0 && impulse.angle === 0) {\n                            continue;\n                        }\n\n                        body.position.x += impulse.x;\n                        body.position.y += impulse.y;\n                        body.angle += impulse.angle;\n                    }\n                };\n\n                /**\n                 * Solves all constraints in a list of collisions.\n                 * @private\n                 * @method solveAll\n                 * @param {constraint[]} constraints\n                 * @param {number} timeScale\n                 */\n                Constraint.solveAll = function (constraints, timeScale) {\n                    // Solve fixed constraints first.\n                    for (var i = 0; i < constraints.length; i += 1) {\n                        var constraint = constraints[i],\n                            fixedA = !constraint.bodyA || constraint.bodyA && constraint.bodyA.isStatic,\n                            fixedB = !constraint.bodyB || constraint.bodyB && constraint.bodyB.isStatic;\n\n                        if (fixedA || fixedB) {\n                            Constraint.solve(constraints[i], timeScale);\n                        }\n                    }\n\n                    // Solve free constraints last.\n                    for (i = 0; i < constraints.length; i += 1) {\n                        constraint = constraints[i];\n                        fixedA = !constraint.bodyA || constraint.bodyA && constraint.bodyA.isStatic;\n                        fixedB = !constraint.bodyB || constraint.bodyB && constraint.bodyB.isStatic;\n\n                        if (!fixedA && !fixedB) {\n                            Constraint.solve(constraints[i], timeScale);\n                        }\n                    }\n                };\n\n                /**\n                 * Solves a distance constraint with Gauss-Siedel method.\n                 * @private\n                 * @method solve\n                 * @param {constraint} constraint\n                 * @param {number} timeScale\n                 */\n                Constraint.solve = function (constraint, timeScale) {\n                    var bodyA = constraint.bodyA,\n                        bodyB = constraint.bodyB,\n                        pointA = constraint.pointA,\n                        pointB = constraint.pointB;\n\n                    if (!bodyA && !bodyB) return;\n\n                    // update reference angle\n                    if (bodyA && !bodyA.isStatic) {\n                        Vector.rotate(pointA, bodyA.angle - constraint.angleA, pointA);\n                        constraint.angleA = bodyA.angle;\n                    }\n\n                    // update reference angle\n                    if (bodyB && !bodyB.isStatic) {\n                        Vector.rotate(pointB, bodyB.angle - constraint.angleB, pointB);\n                        constraint.angleB = bodyB.angle;\n                    }\n\n                    var pointAWorld = pointA,\n                        pointBWorld = pointB;\n\n                    if (bodyA) pointAWorld = Vector.add(bodyA.position, pointA);\n                    if (bodyB) pointBWorld = Vector.add(bodyB.position, pointB);\n\n                    if (!pointAWorld || !pointBWorld) return;\n\n                    var delta = Vector.sub(pointAWorld, pointBWorld),\n                        currentLength = Vector.magnitude(delta);\n\n                    // prevent singularity\n                    if (currentLength < Constraint._minLength) {\n                        currentLength = Constraint._minLength;\n                    }\n\n                    // solve distance constraint with Gauss-Siedel method\n                    var difference = (currentLength - constraint.length) / currentLength,\n                        stiffness = constraint.stiffness < 1 ? constraint.stiffness * timeScale : constraint.stiffness,\n                        force = Vector.mult(delta, difference * stiffness),\n                        massTotal = (bodyA ? bodyA.inverseMass : 0) + (bodyB ? bodyB.inverseMass : 0),\n                        inertiaTotal = (bodyA ? bodyA.inverseInertia : 0) + (bodyB ? bodyB.inverseInertia : 0),\n                        resistanceTotal = massTotal + inertiaTotal,\n                        torque,\n                        share,\n                        normal,\n                        normalVelocity,\n                        relativeVelocity;\n\n                    if (constraint.damping) {\n                        var zero = Vector.create();\n                        normal = Vector.div(delta, currentLength);\n\n                        relativeVelocity = Vector.sub(bodyB && Vector.sub(bodyB.position, bodyB.positionPrev) || zero, bodyA && Vector.sub(bodyA.position, bodyA.positionPrev) || zero);\n\n                        normalVelocity = Vector.dot(normal, relativeVelocity);\n                    }\n\n                    if (bodyA && !bodyA.isStatic) {\n                        share = bodyA.inverseMass / massTotal;\n\n                        // keep track of applied impulses for post solving\n                        bodyA.constraintImpulse.x -= force.x * share;\n                        bodyA.constraintImpulse.y -= force.y * share;\n\n                        // apply forces\n                        bodyA.position.x -= force.x * share;\n                        bodyA.position.y -= force.y * share;\n\n                        // apply damping\n                        if (constraint.damping) {\n                            bodyA.positionPrev.x -= constraint.damping * normal.x * normalVelocity * share;\n                            bodyA.positionPrev.y -= constraint.damping * normal.y * normalVelocity * share;\n                        }\n\n                        // apply torque\n                        torque = Vector.cross(pointA, force) / resistanceTotal * Constraint._torqueDampen * bodyA.inverseInertia * (1 - constraint.angularStiffness);\n                        bodyA.constraintImpulse.angle -= torque;\n                        bodyA.angle -= torque;\n                    }\n\n                    if (bodyB && !bodyB.isStatic) {\n                        share = bodyB.inverseMass / massTotal;\n\n                        // keep track of applied impulses for post solving\n                        bodyB.constraintImpulse.x += force.x * share;\n                        bodyB.constraintImpulse.y += force.y * share;\n\n                        // apply forces\n                        bodyB.position.x += force.x * share;\n                        bodyB.position.y += force.y * share;\n\n                        // apply damping\n                        if (constraint.damping) {\n                            bodyB.positionPrev.x += constraint.damping * normal.x * normalVelocity * share;\n                            bodyB.positionPrev.y += constraint.damping * normal.y * normalVelocity * share;\n                        }\n\n                        // apply torque\n                        torque = Vector.cross(pointB, force) / resistanceTotal * Constraint._torqueDampen * bodyB.inverseInertia * (1 - constraint.angularStiffness);\n                        bodyB.constraintImpulse.angle += torque;\n                        bodyB.angle += torque;\n                    }\n                };\n\n                /**\n                 * Performs body updates required after solving constraints.\n                 * @private\n                 * @method postSolveAll\n                 * @param {body[]} bodies\n                 */\n                Constraint.postSolveAll = function (bodies) {\n                    for (var i = 0; i < bodies.length; i++) {\n                        var body = bodies[i],\n                            impulse = body.constraintImpulse;\n\n                        if (body.isStatic || impulse.x === 0 && impulse.y === 0 && impulse.angle === 0) {\n                            continue;\n                        }\n\n                        Sleeping.set(body, false);\n\n                        // update geometry and reset\n                        for (var j = 0; j < body.parts.length; j++) {\n                            var part = body.parts[j];\n\n                            Vertices.translate(part.vertices, impulse);\n\n                            if (j > 0) {\n                                part.position.x += impulse.x;\n                                part.position.y += impulse.y;\n                            }\n\n                            if (impulse.angle !== 0) {\n                                Vertices.rotate(part.vertices, impulse.angle, body.position);\n                                Axes.rotate(part.axes, impulse.angle);\n                                if (j > 0) {\n                                    Vector.rotateAbout(part.position, impulse.angle, body.position, part.position);\n                                }\n                            }\n\n                            Bounds.update(part.bounds, part.vertices, body.velocity);\n                        }\n\n                        // dampen the cached impulse for warming next step\n                        impulse.angle *= Constraint._warming;\n                        impulse.x *= Constraint._warming;\n                        impulse.y *= Constraint._warming;\n                    }\n                };\n\n                /*\n                *\n                *  Properties Documentation\n                *\n                */\n\n                /**\n                 * An integer `Number` uniquely identifying number generated in `Composite.create` by `Common.nextId`.\n                 *\n                 * @property id\n                 * @type number\n                 */\n\n                /**\n                 * A `String` denoting the type of object.\n                 *\n                 * @property type\n                 * @type string\n                 * @default \"constraint\"\n                 * @readOnly\n                 */\n\n                /**\n                 * An arbitrary `String` name to help the user identify and manage bodies.\n                 *\n                 * @property label\n                 * @type string\n                 * @default \"Constraint\"\n                 */\n\n                /**\n                 * An `Object` that defines the rendering properties to be consumed by the module `Matter.Render`.\n                 *\n                 * @property render\n                 * @type object\n                 */\n\n                /**\n                 * A flag that indicates if the constraint should be rendered.\n                 *\n                 * @property render.visible\n                 * @type boolean\n                 * @default true\n                 */\n\n                /**\n                 * A `Number` that defines the line width to use when rendering the constraint outline.\n                 * A value of `0` means no outline will be rendered.\n                 *\n                 * @property render.lineWidth\n                 * @type number\n                 * @default 2\n                 */\n\n                /**\n                 * A `String` that defines the stroke style to use when rendering the constraint outline.\n                 * It is the same as when using a canvas, so it accepts CSS style property values.\n                 *\n                 * @property render.strokeStyle\n                 * @type string\n                 * @default a random colour\n                 */\n\n                /**\n                 * A `String` that defines the constraint rendering type. \n                 * The possible values are 'line', 'pin', 'spring'.\n                 * An appropriate render type will be automatically chosen unless one is given in options.\n                 *\n                 * @property render.type\n                 * @type string\n                 * @default 'line'\n                 */\n\n                /**\n                 * A `Boolean` that defines if the constraint's anchor points should be rendered.\n                 *\n                 * @property render.anchors\n                 * @type boolean\n                 * @default true\n                 */\n\n                /**\n                 * The first possible `Body` that this constraint is attached to.\n                 *\n                 * @property bodyA\n                 * @type body\n                 * @default null\n                 */\n\n                /**\n                 * The second possible `Body` that this constraint is attached to.\n                 *\n                 * @property bodyB\n                 * @type body\n                 * @default null\n                 */\n\n                /**\n                 * A `Vector` that specifies the offset of the constraint from center of the `constraint.bodyA` if defined, otherwise a world-space position.\n                 *\n                 * @property pointA\n                 * @type vector\n                 * @default { x: 0, y: 0 }\n                 */\n\n                /**\n                 * A `Vector` that specifies the offset of the constraint from center of the `constraint.bodyA` if defined, otherwise a world-space position.\n                 *\n                 * @property pointB\n                 * @type vector\n                 * @default { x: 0, y: 0 }\n                 */\n\n                /**\n                 * A `Number` that specifies the stiffness of the constraint, i.e. the rate at which it returns to its resting `constraint.length`.\n                 * A value of `1` means the constraint should be very stiff.\n                 * A value of `0.2` means the constraint acts like a soft spring.\n                 *\n                 * @property stiffness\n                 * @type number\n                 * @default 1\n                 */\n\n                /**\n                 * A `Number` that specifies the damping of the constraint, \n                 * i.e. the amount of resistance applied to each body based on their velocities to limit the amount of oscillation.\n                 * Damping will only be apparent when the constraint also has a very low `stiffness`.\n                 * A value of `0.1` means the constraint will apply heavy damping, resulting in little to no oscillation.\n                 * A value of `0` means the constraint will apply no damping.\n                 *\n                 * @property damping\n                 * @type number\n                 * @default 0\n                 */\n\n                /**\n                 * A `Number` that specifies the target resting length of the constraint. \n                 * It is calculated automatically in `Constraint.create` from initial positions of the `constraint.bodyA` and `constraint.bodyB`.\n                 *\n                 * @property length\n                 * @type number\n                 */\n\n                /**\n                 * An object reserved for storing plugin-specific properties.\n                 *\n                 * @property plugin\n                 * @type {}\n                 */\n            })();\n        }, { \"../core/Common\": 14, \"../core/Sleeping\": 22, \"../geometry/Axes\": 25, \"../geometry/Bounds\": 26, \"../geometry/Vector\": 28, \"../geometry/Vertices\": 29 }], 13: [function (_dereq_, module, exports) {\n            /**\n            * The `Matter.MouseConstraint` module contains methods for creating mouse constraints.\n            * Mouse constraints are used for allowing user interaction, providing the ability to move bodies via the mouse or touch.\n            *\n            * See the included usage [examples](https://github.com/liabru/matter-js/tree/master/examples).\n            *\n            * @class MouseConstraint\n            */\n\n            var MouseConstraint = {};\n\n            module.exports = MouseConstraint;\n\n            var Vertices = _dereq_('../geometry/Vertices');\n            var Sleeping = _dereq_('../core/Sleeping');\n            var Mouse = _dereq_('../core/Mouse');\n            var Events = _dereq_('../core/Events');\n            var Detector = _dereq_('../collision/Detector');\n            var Constraint = _dereq_('./Constraint');\n            var Composite = _dereq_('../body/Composite');\n            var Common = _dereq_('../core/Common');\n            var Bounds = _dereq_('../geometry/Bounds');\n\n            (function () {\n\n                /**\n                 * Creates a new mouse constraint.\n                 * All properties have default values, and many are pre-calculated automatically based on other properties.\n                 * See the properties section below for detailed information on what you can pass via the `options` object.\n                 * @method create\n                 * @param {engine} engine\n                 * @param {} options\n                 * @return {MouseConstraint} A new MouseConstraint\n                 */\n                MouseConstraint.create = function (engine, options) {\n                    var mouse = (engine ? engine.mouse : null) || (options ? options.mouse : null);\n\n                    if (!mouse) {\n                        if (engine && engine.render && engine.render.canvas) {\n                            mouse = Mouse.create(engine.render.canvas);\n                        } else if (options && options.element) {\n                            mouse = Mouse.create(options.element);\n                        } else {\n                            mouse = Mouse.create();\n                            Common.warn('MouseConstraint.create: options.mouse was undefined, options.element was undefined, may not function as expected');\n                        }\n                    }\n\n                    var constraint = Constraint.create({\n                        label: 'Mouse Constraint',\n                        pointA: mouse.position,\n                        pointB: { x: 0, y: 0 },\n                        length: 0.01,\n                        stiffness: 0.1,\n                        angularStiffness: 1,\n                        render: {\n                            strokeStyle: '#90EE90',\n                            lineWidth: 3\n                        }\n                    });\n\n                    var defaults = {\n                        type: 'mouseConstraint',\n                        mouse: mouse,\n                        element: null,\n                        body: null,\n                        constraint: constraint,\n                        collisionFilter: {\n                            category: 0x0001,\n                            mask: 0xFFFFFFFF,\n                            group: 0\n                        }\n                    };\n\n                    var mouseConstraint = Common.extend(defaults, options);\n\n                    Events.on(engine, 'beforeUpdate', function () {\n                        var allBodies = Composite.allBodies(engine.world);\n                        MouseConstraint.update(mouseConstraint, allBodies);\n                        MouseConstraint._triggerEvents(mouseConstraint);\n                    });\n\n                    return mouseConstraint;\n                };\n\n                /**\n                 * Updates the given mouse constraint.\n                 * @private\n                 * @method update\n                 * @param {MouseConstraint} mouseConstraint\n                 * @param {body[]} bodies\n                 */\n                MouseConstraint.update = function (mouseConstraint, bodies) {\n                    var mouse = mouseConstraint.mouse,\n                        constraint = mouseConstraint.constraint,\n                        body = mouseConstraint.body;\n\n                    if (mouse.button === 0) {\n                        if (!constraint.bodyB) {\n                            for (var i = 0; i < bodies.length; i++) {\n                                body = bodies[i];\n                                if (Bounds.contains(body.bounds, mouse.position) && Detector.canCollide(body.collisionFilter, mouseConstraint.collisionFilter)) {\n                                    for (var j = body.parts.length > 1 ? 1 : 0; j < body.parts.length; j++) {\n                                        var part = body.parts[j];\n                                        if (Vertices.contains(part.vertices, mouse.position)) {\n                                            constraint.pointA = mouse.position;\n                                            constraint.bodyB = mouseConstraint.body = body;\n                                            constraint.pointB = { x: mouse.position.x - body.position.x, y: mouse.position.y - body.position.y };\n                                            constraint.angleB = body.angle;\n\n                                            Sleeping.set(body, false);\n                                            Events.trigger(mouseConstraint, 'startdrag', { mouse: mouse, body: body });\n\n                                            break;\n                                        }\n                                    }\n                                }\n                            }\n                        } else {\n                            Sleeping.set(constraint.bodyB, false);\n                            constraint.pointA = mouse.position;\n                        }\n                    } else {\n                        constraint.bodyB = mouseConstraint.body = null;\n                        constraint.pointB = null;\n\n                        if (body) Events.trigger(mouseConstraint, 'enddrag', { mouse: mouse, body: body });\n                    }\n                };\n\n                /**\n                 * Triggers mouse constraint events.\n                 * @method _triggerEvents\n                 * @private\n                 * @param {mouse} mouseConstraint\n                 */\n                MouseConstraint._triggerEvents = function (mouseConstraint) {\n                    var mouse = mouseConstraint.mouse,\n                        mouseEvents = mouse.sourceEvents;\n\n                    if (mouseEvents.mousemove) Events.trigger(mouseConstraint, 'mousemove', { mouse: mouse });\n\n                    if (mouseEvents.mousedown) Events.trigger(mouseConstraint, 'mousedown', { mouse: mouse });\n\n                    if (mouseEvents.mouseup) Events.trigger(mouseConstraint, 'mouseup', { mouse: mouse });\n\n                    // reset the mouse state ready for the next step\n                    Mouse.clearSourceEvents(mouse);\n                };\n\n                /*\n                *\n                *  Events Documentation\n                *\n                */\n\n                /**\n                * Fired when the mouse has moved (or a touch moves) during the last step\n                *\n                * @event mousemove\n                * @param {} event An event object\n                * @param {mouse} event.mouse The engine's mouse instance\n                * @param {} event.source The source object of the event\n                * @param {} event.name The name of the event\n                */\n\n                /**\n                * Fired when the mouse is down (or a touch has started) during the last step\n                *\n                * @event mousedown\n                * @param {} event An event object\n                * @param {mouse} event.mouse The engine's mouse instance\n                * @param {} event.source The source object of the event\n                * @param {} event.name The name of the event\n                */\n\n                /**\n                * Fired when the mouse is up (or a touch has ended) during the last step\n                *\n                * @event mouseup\n                * @param {} event An event object\n                * @param {mouse} event.mouse The engine's mouse instance\n                * @param {} event.source The source object of the event\n                * @param {} event.name The name of the event\n                */\n\n                /**\n                * Fired when the user starts dragging a body\n                *\n                * @event startdrag\n                * @param {} event An event object\n                * @param {mouse} event.mouse The engine's mouse instance\n                * @param {body} event.body The body being dragged\n                * @param {} event.source The source object of the event\n                * @param {} event.name The name of the event\n                */\n\n                /**\n                * Fired when the user ends dragging a body\n                *\n                * @event enddrag\n                * @param {} event An event object\n                * @param {mouse} event.mouse The engine's mouse instance\n                * @param {body} event.body The body that has stopped being dragged\n                * @param {} event.source The source object of the event\n                * @param {} event.name The name of the event\n                */\n\n                /*\n                *\n                *  Properties Documentation\n                *\n                */\n\n                /**\n                 * A `String` denoting the type of object.\n                 *\n                 * @property type\n                 * @type string\n                 * @default \"constraint\"\n                 * @readOnly\n                 */\n\n                /**\n                 * The `Mouse` instance in use. If not supplied in `MouseConstraint.create`, one will be created.\n                 *\n                 * @property mouse\n                 * @type mouse\n                 * @default mouse\n                 */\n\n                /**\n                 * The `Body` that is currently being moved by the user, or `null` if no body.\n                 *\n                 * @property body\n                 * @type body\n                 * @default null\n                 */\n\n                /**\n                 * The `Constraint` object that is used to move the body during interaction.\n                 *\n                 * @property constraint\n                 * @type constraint\n                 */\n\n                /**\n                 * An `Object` that specifies the collision filter properties.\n                 * The collision filter allows the user to define which types of body this mouse constraint can interact with.\n                 * See `body.collisionFilter` for more information.\n                 *\n                 * @property collisionFilter\n                 * @type object\n                 */\n            })();\n        }, { \"../body/Composite\": 2, \"../collision/Detector\": 5, \"../core/Common\": 14, \"../core/Events\": 16, \"../core/Mouse\": 19, \"../core/Sleeping\": 22, \"../geometry/Bounds\": 26, \"../geometry/Vertices\": 29, \"./Constraint\": 12 }], 14: [function (_dereq_, module, exports) {\n            /**\n            * The `Matter.Common` module contains utility functions that are common to all modules.\n            *\n            * @class Common\n            */\n\n            var Common = {};\n\n            module.exports = Common;\n\n            (function () {\n\n                Common._nextId = 0;\n                Common._seed = 0;\n                Common._nowStartTime = +new Date();\n\n                /**\n                 * Extends the object in the first argument using the object in the second argument.\n                 * @method extend\n                 * @param {} obj\n                 * @param {boolean} deep\n                 * @return {} obj extended\n                 */\n                Common.extend = function (obj, deep) {\n                    var argsStart, args, deepClone;\n\n                    if (typeof deep === 'boolean') {\n                        argsStart = 2;\n                        deepClone = deep;\n                    } else {\n                        argsStart = 1;\n                        deepClone = true;\n                    }\n\n                    for (var i = argsStart; i < arguments.length; i++) {\n                        var source = arguments[i];\n\n                        if (source) {\n                            for (var prop in source) {\n                                if (deepClone && source[prop] && source[prop].constructor === Object) {\n                                    if (!obj[prop] || obj[prop].constructor === Object) {\n                                        obj[prop] = obj[prop] || {};\n                                        Common.extend(obj[prop], deepClone, source[prop]);\n                                    } else {\n                                        obj[prop] = source[prop];\n                                    }\n                                } else {\n                                    obj[prop] = source[prop];\n                                }\n                            }\n                        }\n                    }\n\n                    return obj;\n                };\n\n                /**\n                 * Creates a new clone of the object, if deep is true references will also be cloned.\n                 * @method clone\n                 * @param {} obj\n                 * @param {bool} deep\n                 * @return {} obj cloned\n                 */\n                Common.clone = function (obj, deep) {\n                    return Common.extend({}, deep, obj);\n                };\n\n                /**\n                 * Returns the list of keys for the given object.\n                 * @method keys\n                 * @param {} obj\n                 * @return {string[]} keys\n                 */\n                Common.keys = function (obj) {\n                    if (Object.keys) return Object.keys(obj);\n\n                    // avoid hasOwnProperty for performance\n                    var keys = [];\n                    for (var key in obj) {\n                        keys.push(key);\n                    }return keys;\n                };\n\n                /**\n                 * Returns the list of values for the given object.\n                 * @method values\n                 * @param {} obj\n                 * @return {array} Array of the objects property values\n                 */\n                Common.values = function (obj) {\n                    var values = [];\n\n                    if (Object.keys) {\n                        var keys = Object.keys(obj);\n                        for (var i = 0; i < keys.length; i++) {\n                            values.push(obj[keys[i]]);\n                        }\n                        return values;\n                    }\n\n                    // avoid hasOwnProperty for performance\n                    for (var key in obj) {\n                        values.push(obj[key]);\n                    }return values;\n                };\n\n                /**\n                 * Gets a value from `base` relative to the `path` string.\n                 * @method get\n                 * @param {} obj The base object\n                 * @param {string} path The path relative to `base`, e.g. 'Foo.Bar.baz'\n                 * @param {number} [begin] Path slice begin\n                 * @param {number} [end] Path slice end\n                 * @return {} The object at the given path\n                 */\n                Common.get = function (obj, path, begin, end) {\n                    path = path.split('.').slice(begin, end);\n\n                    for (var i = 0; i < path.length; i += 1) {\n                        obj = obj[path[i]];\n                    }\n\n                    return obj;\n                };\n\n                /**\n                 * Sets a value on `base` relative to the given `path` string.\n                 * @method set\n                 * @param {} obj The base object\n                 * @param {string} path The path relative to `base`, e.g. 'Foo.Bar.baz'\n                 * @param {} val The value to set\n                 * @param {number} [begin] Path slice begin\n                 * @param {number} [end] Path slice end\n                 * @return {} Pass through `val` for chaining\n                 */\n                Common.set = function (obj, path, val, begin, end) {\n                    var parts = path.split('.').slice(begin, end);\n                    Common.get(obj, path, 0, -1)[parts[parts.length - 1]] = val;\n                    return val;\n                };\n\n                /**\n                 * Shuffles the given array in-place.\n                 * The function uses a seeded random generator.\n                 * @method shuffle\n                 * @param {array} array\n                 * @return {array} array shuffled randomly\n                 */\n                Common.shuffle = function (array) {\n                    for (var i = array.length - 1; i > 0; i--) {\n                        var j = Math.floor(Common.random() * (i + 1));\n                        var temp = array[i];\n                        array[i] = array[j];\n                        array[j] = temp;\n                    }\n                    return array;\n                };\n\n                /**\n                 * Randomly chooses a value from a list with equal probability.\n                 * The function uses a seeded random generator.\n                 * @method choose\n                 * @param {array} choices\n                 * @return {object} A random choice object from the array\n                 */\n                Common.choose = function (choices) {\n                    return choices[Math.floor(Common.random() * choices.length)];\n                };\n\n                /**\n                 * Returns true if the object is a HTMLElement, otherwise false.\n                 * @method isElement\n                 * @param {object} obj\n                 * @return {boolean} True if the object is a HTMLElement, otherwise false\n                 */\n                Common.isElement = function (obj) {\n                    if (typeof HTMLElement !== 'undefined') {\n                        return obj instanceof HTMLElement;\n                    }\n\n                    return !!(obj && obj.nodeType && obj.nodeName);\n                };\n\n                /**\n                 * Returns true if the object is an array.\n                 * @method isArray\n                 * @param {object} obj\n                 * @return {boolean} True if the object is an array, otherwise false\n                 */\n                Common.isArray = function (obj) {\n                    return Object.prototype.toString.call(obj) === '[object Array]';\n                };\n\n                /**\n                 * Returns true if the object is a function.\n                 * @method isFunction\n                 * @param {object} obj\n                 * @return {boolean} True if the object is a function, otherwise false\n                 */\n                Common.isFunction = function (obj) {\n                    return typeof obj === \"function\";\n                };\n\n                /**\n                 * Returns true if the object is a plain object.\n                 * @method isPlainObject\n                 * @param {object} obj\n                 * @return {boolean} True if the object is a plain object, otherwise false\n                 */\n                Common.isPlainObject = function (obj) {\n                    return (typeof obj === \"undefined\" ? \"undefined\" : _typeof(obj)) === 'object' && obj.constructor === Object;\n                };\n\n                /**\n                 * Returns true if the object is a string.\n                 * @method isString\n                 * @param {object} obj\n                 * @return {boolean} True if the object is a string, otherwise false\n                 */\n                Common.isString = function (obj) {\n                    return toString.call(obj) === '[object String]';\n                };\n\n                /**\n                 * Returns the given value clamped between a minimum and maximum value.\n                 * @method clamp\n                 * @param {number} value\n                 * @param {number} min\n                 * @param {number} max\n                 * @return {number} The value clamped between min and max inclusive\n                 */\n                Common.clamp = function (value, min, max) {\n                    if (value < min) return min;\n                    if (value > max) return max;\n                    return value;\n                };\n\n                /**\n                 * Returns the sign of the given value.\n                 * @method sign\n                 * @param {number} value\n                 * @return {number} -1 if negative, +1 if 0 or positive\n                 */\n                Common.sign = function (value) {\n                    return value < 0 ? -1 : 1;\n                };\n\n                /**\n                 * Returns the current timestamp since the time origin (e.g. from page load).\n                 * The result will be high-resolution including decimal places if available.\n                 * @method now\n                 * @return {number} the current timestamp\n                 */\n                Common.now = function () {\n                    if (window.performance) {\n                        if (window.performance.now) {\n                            return window.performance.now();\n                        } else if (window.performance.webkitNow) {\n                            return window.performance.webkitNow();\n                        }\n                    }\n\n                    return new Date() - Common._nowStartTime;\n                };\n\n                /**\n                 * Returns a random value between a minimum and a maximum value inclusive.\n                 * The function uses a seeded random generator.\n                 * @method random\n                 * @param {number} min\n                 * @param {number} max\n                 * @return {number} A random number between min and max inclusive\n                 */\n                Common.random = function (min, max) {\n                    min = typeof min !== \"undefined\" ? min : 0;\n                    max = typeof max !== \"undefined\" ? max : 1;\n                    return min + _seededRandom() * (max - min);\n                };\n\n                var _seededRandom = function _seededRandom() {\n                    // https://en.wikipedia.org/wiki/Linear_congruential_generator\n                    Common._seed = (Common._seed * 9301 + 49297) % 233280;\n                    return Common._seed / 233280;\n                };\n\n                /**\n                 * Converts a CSS hex colour string into an integer.\n                 * @method colorToNumber\n                 * @param {string} colorString\n                 * @return {number} An integer representing the CSS hex string\n                 */\n                Common.colorToNumber = function (colorString) {\n                    colorString = colorString.replace('#', '');\n\n                    if (colorString.length == 3) {\n                        colorString = colorString.charAt(0) + colorString.charAt(0) + colorString.charAt(1) + colorString.charAt(1) + colorString.charAt(2) + colorString.charAt(2);\n                    }\n\n                    return parseInt(colorString, 16);\n                };\n\n                /**\n                 * The console logging level to use, where each level includes all levels above and excludes the levels below.\n                 * The default level is 'debug' which shows all console messages.  \n                 *\n                 * Possible level values are:\n                 * - 0 = None\n                 * - 1 = Debug\n                 * - 2 = Info\n                 * - 3 = Warn\n                 * - 4 = Error\n                 * @property Common.logLevel\n                 * @type {Number}\n                 * @default 1\n                 */\n                Common.logLevel = 1;\n\n                /**\n                 * Shows a `console.log` message only if the current `Common.logLevel` allows it.\n                 * The message will be prefixed with 'matter-js' to make it easily identifiable.\n                 * @method log\n                 * @param ...objs {} The objects to log.\n                 */\n                Common.log = function () {\n                    if (console && Common.logLevel > 0 && Common.logLevel <= 3) {\n                        console.log.apply(console, ['matter-js:'].concat(Array.prototype.slice.call(arguments)));\n                    }\n                };\n\n                /**\n                 * Shows a `console.info` message only if the current `Common.logLevel` allows it.\n                 * The message will be prefixed with 'matter-js' to make it easily identifiable.\n                 * @method info\n                 * @param ...objs {} The objects to log.\n                 */\n                Common.info = function () {\n                    if (console && Common.logLevel > 0 && Common.logLevel <= 2) {\n                        console.info.apply(console, ['matter-js:'].concat(Array.prototype.slice.call(arguments)));\n                    }\n                };\n\n                /**\n                 * Shows a `console.warn` message only if the current `Common.logLevel` allows it.\n                 * The message will be prefixed with 'matter-js' to make it easily identifiable.\n                 * @method warn\n                 * @param ...objs {} The objects to log.\n                 */\n                Common.warn = function () {\n                    if (console && Common.logLevel > 0 && Common.logLevel <= 3) {\n                        console.warn.apply(console, ['matter-js:'].concat(Array.prototype.slice.call(arguments)));\n                    }\n                };\n\n                /**\n                 * Returns the next unique sequential ID.\n                 * @method nextId\n                 * @return {Number} Unique sequential ID\n                 */\n                Common.nextId = function () {\n                    return Common._nextId++;\n                };\n\n                /**\n                 * A cross browser compatible indexOf implementation.\n                 * @method indexOf\n                 * @param {array} haystack\n                 * @param {object} needle\n                 * @return {number} The position of needle in haystack, otherwise -1.\n                 */\n                Common.indexOf = function (haystack, needle) {\n                    if (haystack.indexOf) return haystack.indexOf(needle);\n\n                    for (var i = 0; i < haystack.length; i++) {\n                        if (haystack[i] === needle) return i;\n                    }\n\n                    return -1;\n                };\n\n                /**\n                 * A cross browser compatible array map implementation.\n                 * @method map\n                 * @param {array} list\n                 * @param {function} func\n                 * @return {array} Values from list transformed by func.\n                 */\n                Common.map = function (list, func) {\n                    if (list.map) {\n                        return list.map(func);\n                    }\n\n                    var mapped = [];\n\n                    for (var i = 0; i < list.length; i += 1) {\n                        mapped.push(func(list[i]));\n                    }\n\n                    return mapped;\n                };\n\n                /**\n                 * Takes a directed graph and returns the partially ordered set of vertices in topological order.\n                 * Circular dependencies are allowed.\n                 * @method topologicalSort\n                 * @param {object} graph\n                 * @return {array} Partially ordered set of vertices in topological order.\n                 */\n                Common.topologicalSort = function (graph) {\n                    // https://github.com/mgechev/javascript-algorithms\n                    // Copyright (c) Minko Gechev (MIT license)\n                    // Modifications: tidy formatting and naming\n                    var result = [],\n                        visited = [],\n                        temp = [];\n\n                    for (var node in graph) {\n                        if (!visited[node] && !temp[node]) {\n                            Common._topologicalSort(node, visited, temp, graph, result);\n                        }\n                    }\n\n                    return result;\n                };\n\n                Common._topologicalSort = function (node, visited, temp, graph, result) {\n                    var neighbors = graph[node] || [];\n                    temp[node] = true;\n\n                    for (var i = 0; i < neighbors.length; i += 1) {\n                        var neighbor = neighbors[i];\n\n                        if (temp[neighbor]) {\n                            // skip circular dependencies\n                            continue;\n                        }\n\n                        if (!visited[neighbor]) {\n                            Common._topologicalSort(neighbor, visited, temp, graph, result);\n                        }\n                    }\n\n                    temp[node] = false;\n                    visited[node] = true;\n\n                    result.push(node);\n                };\n\n                /**\n                 * Takes _n_ functions as arguments and returns a new function that calls them in order.\n                 * The arguments applied when calling the new function will also be applied to every function passed.\n                 * The value of `this` refers to the last value returned in the chain that was not `undefined`.\n                 * Therefore if a passed function does not return a value, the previously returned value is maintained.\n                 * After all passed functions have been called the new function returns the last returned value (if any).\n                 * If any of the passed functions are a chain, then the chain will be flattened.\n                 * @method chain\n                 * @param ...funcs {function} The functions to chain.\n                 * @return {function} A new function that calls the passed functions in order.\n                 */\n                Common.chain = function () {\n                    var funcs = [];\n\n                    for (var i = 0; i < arguments.length; i += 1) {\n                        var func = arguments[i];\n\n                        if (func._chained) {\n                            // flatten already chained functions\n                            funcs.push.apply(funcs, func._chained);\n                        } else {\n                            funcs.push(func);\n                        }\n                    }\n\n                    var chain = function chain() {\n                        // https://github.com/GoogleChrome/devtools-docs/issues/53#issuecomment-51941358\n                        var lastResult,\n                            args = new Array(arguments.length);\n\n                        for (var i = 0, l = arguments.length; i < l; i++) {\n                            args[i] = arguments[i];\n                        }\n\n                        for (i = 0; i < funcs.length; i += 1) {\n                            var result = funcs[i].apply(lastResult, args);\n\n                            if (typeof result !== 'undefined') {\n                                lastResult = result;\n                            }\n                        }\n\n                        return lastResult;\n                    };\n\n                    chain._chained = funcs;\n\n                    return chain;\n                };\n\n                /**\n                 * Chains a function to excute before the original function on the given `path` relative to `base`.\n                 * See also docs for `Common.chain`.\n                 * @method chainPathBefore\n                 * @param {} base The base object\n                 * @param {string} path The path relative to `base`\n                 * @param {function} func The function to chain before the original\n                 * @return {function} The chained function that replaced the original\n                 */\n                Common.chainPathBefore = function (base, path, func) {\n                    return Common.set(base, path, Common.chain(func, Common.get(base, path)));\n                };\n\n                /**\n                 * Chains a function to excute after the original function on the given `path` relative to `base`.\n                 * See also docs for `Common.chain`.\n                 * @method chainPathAfter\n                 * @param {} base The base object\n                 * @param {string} path The path relative to `base`\n                 * @param {function} func The function to chain after the original\n                 * @return {function} The chained function that replaced the original\n                 */\n                Common.chainPathAfter = function (base, path, func) {\n                    return Common.set(base, path, Common.chain(Common.get(base, path), func));\n                };\n            })();\n        }, {}], 15: [function (_dereq_, module, exports) {\n            /**\n            * The `Matter.Engine` module contains methods for creating and manipulating engines.\n            * An engine is a controller that manages updating the simulation of the world.\n            * See `Matter.Runner` for an optional game loop utility.\n            *\n            * See the included usage [examples](https://github.com/liabru/matter-js/tree/master/examples).\n            *\n            * @class Engine\n            */\n\n            var Engine = {};\n\n            module.exports = Engine;\n\n            var World = _dereq_('../body/World');\n            var Sleeping = _dereq_('./Sleeping');\n            var Resolver = _dereq_('../collision/Resolver');\n            var Render = _dereq_('../render/Render');\n            var Pairs = _dereq_('../collision/Pairs');\n            var Metrics = _dereq_('./Metrics');\n            var Grid = _dereq_('../collision/Grid');\n            var Events = _dereq_('./Events');\n            var Composite = _dereq_('../body/Composite');\n            var Constraint = _dereq_('../constraint/Constraint');\n            var Common = _dereq_('./Common');\n            var Body = _dereq_('../body/Body');\n\n            (function () {\n\n                /**\n                 * Creates a new engine. The options parameter is an object that specifies any properties you wish to override the defaults.\n                 * All properties have default values, and many are pre-calculated automatically based on other properties.\n                 * See the properties section below for detailed information on what you can pass via the `options` object.\n                 * @method create\n                 * @param {object} [options]\n                 * @return {engine} engine\n                 */\n                Engine.create = function (element, options) {\n                    // options may be passed as the first (and only) argument\n                    options = Common.isElement(element) ? options : element;\n                    element = Common.isElement(element) ? element : null;\n                    options = options || {};\n\n                    if (element || options.render) {\n                        Common.warn('Engine.create: engine.render is deprecated (see docs)');\n                    }\n\n                    var defaults = {\n                        positionIterations: 6,\n                        velocityIterations: 4,\n                        constraintIterations: 2,\n                        enableSleeping: false,\n                        events: [],\n                        plugin: {},\n                        timing: {\n                            timestamp: 0,\n                            timeScale: 1\n                        },\n                        broadphase: {\n                            controller: Grid\n                        }\n                    };\n\n                    var engine = Common.extend(defaults, options);\n\n                    // @deprecated\n                    if (element || engine.render) {\n                        var renderDefaults = {\n                            element: element,\n                            controller: Render\n                        };\n\n                        engine.render = Common.extend(renderDefaults, engine.render);\n                    }\n\n                    // @deprecated\n                    if (engine.render && engine.render.controller) {\n                        engine.render = engine.render.controller.create(engine.render);\n                    }\n\n                    // @deprecated\n                    if (engine.render) {\n                        engine.render.engine = engine;\n                    }\n\n                    engine.world = options.world || World.create(engine.world);\n                    engine.pairs = Pairs.create();\n                    engine.broadphase = engine.broadphase.controller.create(engine.broadphase);\n                    engine.metrics = engine.metrics || { extended: false };\n\n                    return engine;\n                };\n\n                /**\n                 * Moves the simulation forward in time by `delta` ms.\n                 * The `correction` argument is an optional `Number` that specifies the time correction factor to apply to the update.\n                 * This can help improve the accuracy of the simulation in cases where `delta` is changing between updates.\n                 * The value of `correction` is defined as `delta / lastDelta`, i.e. the percentage change of `delta` over the last step.\n                 * Therefore the value is always `1` (no correction) when `delta` constant (or when no correction is desired, which is the default).\n                 * See the paper on <a href=\"http://lonesock.net/article/verlet.html\">Time Corrected Verlet</a> for more information.\n                 *\n                 * Triggers `beforeUpdate` and `afterUpdate` events.\n                 * Triggers `collisionStart`, `collisionActive` and `collisionEnd` events.\n                 * @method update\n                 * @param {engine} engine\n                 * @param {number} [delta=16.666]\n                 * @param {number} [correction=1]\n                 */\n                Engine.update = function (engine, delta, correction) {\n                    delta = delta || 1000 / 60;\n                    correction = correction || 1;\n\n                    var world = engine.world,\n                        timing = engine.timing,\n                        broadphase = engine.broadphase,\n                        broadphasePairs = [],\n                        i;\n\n                    // increment timestamp\n                    timing.timestamp += delta * timing.timeScale;\n\n                    // create an event object\n                    var event = {\n                        timestamp: timing.timestamp\n                    };\n\n                    Events.trigger(engine, 'beforeUpdate', event);\n\n                    // get lists of all bodies and constraints, no matter what composites they are in\n                    var allBodies = Composite.allBodies(world),\n                        allConstraints = Composite.allConstraints(world);\n\n                    // if sleeping enabled, call the sleeping controller\n                    if (engine.enableSleeping) Sleeping.update(allBodies, timing.timeScale);\n\n                    // applies gravity to all bodies\n                    Engine._bodiesApplyGravity(allBodies, world.gravity);\n\n                    // update all body position and rotation by integration\n                    Engine._bodiesUpdate(allBodies, delta, timing.timeScale, correction, world.bounds);\n\n                    // update all constraints (first pass)\n                    Constraint.preSolveAll(allBodies);\n                    for (i = 0; i < engine.constraintIterations; i++) {\n                        Constraint.solveAll(allConstraints, timing.timeScale);\n                    }\n                    Constraint.postSolveAll(allBodies);\n\n                    // broadphase pass: find potential collision pairs\n                    if (broadphase.controller) {\n                        // if world is dirty, we must flush the whole grid\n                        if (world.isModified) broadphase.controller.clear(broadphase);\n\n                        // update the grid buckets based on current bodies\n                        broadphase.controller.update(broadphase, allBodies, engine, world.isModified);\n                        broadphasePairs = broadphase.pairsList;\n                    } else {\n                        // if no broadphase set, we just pass all bodies\n                        broadphasePairs = allBodies;\n                    }\n\n                    // clear all composite modified flags\n                    if (world.isModified) {\n                        Composite.setModified(world, false, false, true);\n                    }\n\n                    // narrowphase pass: find actual collisions, then create or update collision pairs\n                    var collisions = broadphase.detector(broadphasePairs, engine);\n\n                    // update collision pairs\n                    var pairs = engine.pairs,\n                        timestamp = timing.timestamp;\n                    Pairs.update(pairs, collisions, timestamp);\n                    Pairs.removeOld(pairs, timestamp);\n\n                    // wake up bodies involved in collisions\n                    if (engine.enableSleeping) Sleeping.afterCollisions(pairs.list, timing.timeScale);\n\n                    // trigger collision events\n                    if (pairs.collisionStart.length > 0) Events.trigger(engine, 'collisionStart', { pairs: pairs.collisionStart });\n\n                    // iteratively resolve position between collisions\n                    Resolver.preSolvePosition(pairs.list);\n                    for (i = 0; i < engine.positionIterations; i++) {\n                        Resolver.solvePosition(pairs.list, timing.timeScale);\n                    }\n                    Resolver.postSolvePosition(allBodies);\n\n                    // update all constraints (second pass)\n                    Constraint.preSolveAll(allBodies);\n                    for (i = 0; i < engine.constraintIterations; i++) {\n                        Constraint.solveAll(allConstraints, timing.timeScale);\n                    }\n                    Constraint.postSolveAll(allBodies);\n\n                    // iteratively resolve velocity between collisions\n                    Resolver.preSolveVelocity(pairs.list);\n                    for (i = 0; i < engine.velocityIterations; i++) {\n                        Resolver.solveVelocity(pairs.list, timing.timeScale);\n                    }\n\n                    // trigger collision events\n                    if (pairs.collisionActive.length > 0) Events.trigger(engine, 'collisionActive', { pairs: pairs.collisionActive });\n\n                    if (pairs.collisionEnd.length > 0) Events.trigger(engine, 'collisionEnd', { pairs: pairs.collisionEnd });\n\n                    // clear force buffers\n                    Engine._bodiesClearForces(allBodies);\n\n                    Events.trigger(engine, 'afterUpdate', event);\n\n                    return engine;\n                };\n\n                /**\n                 * Merges two engines by keeping the configuration of `engineA` but replacing the world with the one from `engineB`.\n                 * @method merge\n                 * @param {engine} engineA\n                 * @param {engine} engineB\n                 */\n                Engine.merge = function (engineA, engineB) {\n                    Common.extend(engineA, engineB);\n\n                    if (engineB.world) {\n                        engineA.world = engineB.world;\n\n                        Engine.clear(engineA);\n\n                        var bodies = Composite.allBodies(engineA.world);\n\n                        for (var i = 0; i < bodies.length; i++) {\n                            var body = bodies[i];\n                            Sleeping.set(body, false);\n                            body.id = Common.nextId();\n                        }\n                    }\n                };\n\n                /**\n                 * Clears the engine including the world, pairs and broadphase.\n                 * @method clear\n                 * @param {engine} engine\n                 */\n                Engine.clear = function (engine) {\n                    var world = engine.world;\n\n                    Pairs.clear(engine.pairs);\n\n                    var broadphase = engine.broadphase;\n                    if (broadphase.controller) {\n                        var bodies = Composite.allBodies(world);\n                        broadphase.controller.clear(broadphase);\n                        broadphase.controller.update(broadphase, bodies, engine, true);\n                    }\n                };\n\n                /**\n                 * Zeroes the `body.force` and `body.torque` force buffers.\n                 * @method _bodiesClearForces\n                 * @private\n                 * @param {body[]} bodies\n                 */\n                Engine._bodiesClearForces = function (bodies) {\n                    for (var i = 0; i < bodies.length; i++) {\n                        var body = bodies[i];\n\n                        // reset force buffers\n                        body.force.x = 0;\n                        body.force.y = 0;\n                        body.torque = 0;\n                    }\n                };\n\n                /**\n                 * Applys a mass dependant force to all given bodies.\n                 * @method _bodiesApplyGravity\n                 * @private\n                 * @param {body[]} bodies\n                 * @param {vector} gravity\n                 */\n                Engine._bodiesApplyGravity = function (bodies, gravity) {\n                    var gravityScale = typeof gravity.scale !== 'undefined' ? gravity.scale : 0.001;\n\n                    if (gravity.x === 0 && gravity.y === 0 || gravityScale === 0) {\n                        return;\n                    }\n\n                    for (var i = 0; i < bodies.length; i++) {\n                        var body = bodies[i];\n\n                        if (body.isStatic || body.isSleeping) continue;\n\n                        // apply gravity\n                        body.force.y += body.mass * gravity.y * gravityScale;\n                        body.force.x += body.mass * gravity.x * gravityScale;\n                    }\n                };\n\n                /**\n                 * Applys `Body.update` to all given `bodies`.\n                 * @method _bodiesUpdate\n                 * @private\n                 * @param {body[]} bodies\n                 * @param {number} deltaTime \n                 * The amount of time elapsed between updates\n                 * @param {number} timeScale\n                 * @param {number} correction \n                 * The Verlet correction factor (deltaTime / lastDeltaTime)\n                 * @param {bounds} worldBounds\n                 */\n                Engine._bodiesUpdate = function (bodies, deltaTime, timeScale, correction, worldBounds) {\n                    for (var i = 0; i < bodies.length; i++) {\n                        var body = bodies[i];\n\n                        if (body.isStatic || body.isSleeping) continue;\n\n                        Body.update(body, deltaTime, timeScale, correction);\n                    }\n                };\n\n                /**\n                 * An alias for `Runner.run`, see `Matter.Runner` for more information.\n                 * @method run\n                 * @param {engine} engine\n                 */\n\n                /**\n                * Fired just before an update\n                *\n                * @event beforeUpdate\n                * @param {} event An event object\n                * @param {number} event.timestamp The engine.timing.timestamp of the event\n                * @param {} event.source The source object of the event\n                * @param {} event.name The name of the event\n                */\n\n                /**\n                * Fired after engine update and all collision events\n                *\n                * @event afterUpdate\n                * @param {} event An event object\n                * @param {number} event.timestamp The engine.timing.timestamp of the event\n                * @param {} event.source The source object of the event\n                * @param {} event.name The name of the event\n                */\n\n                /**\n                * Fired after engine update, provides a list of all pairs that have started to collide in the current tick (if any)\n                *\n                * @event collisionStart\n                * @param {} event An event object\n                * @param {} event.pairs List of affected pairs\n                * @param {number} event.timestamp The engine.timing.timestamp of the event\n                * @param {} event.source The source object of the event\n                * @param {} event.name The name of the event\n                */\n\n                /**\n                * Fired after engine update, provides a list of all pairs that are colliding in the current tick (if any)\n                *\n                * @event collisionActive\n                * @param {} event An event object\n                * @param {} event.pairs List of affected pairs\n                * @param {number} event.timestamp The engine.timing.timestamp of the event\n                * @param {} event.source The source object of the event\n                * @param {} event.name The name of the event\n                */\n\n                /**\n                * Fired after engine update, provides a list of all pairs that have ended collision in the current tick (if any)\n                *\n                * @event collisionEnd\n                * @param {} event An event object\n                * @param {} event.pairs List of affected pairs\n                * @param {number} event.timestamp The engine.timing.timestamp of the event\n                * @param {} event.source The source object of the event\n                * @param {} event.name The name of the event\n                */\n\n                /*\n                *\n                *  Properties Documentation\n                *\n                */\n\n                /**\n                 * An integer `Number` that specifies the number of position iterations to perform each update.\n                 * The higher the value, the higher quality the simulation will be at the expense of performance.\n                 *\n                 * @property positionIterations\n                 * @type number\n                 * @default 6\n                 */\n\n                /**\n                 * An integer `Number` that specifies the number of velocity iterations to perform each update.\n                 * The higher the value, the higher quality the simulation will be at the expense of performance.\n                 *\n                 * @property velocityIterations\n                 * @type number\n                 * @default 4\n                 */\n\n                /**\n                 * An integer `Number` that specifies the number of constraint iterations to perform each update.\n                 * The higher the value, the higher quality the simulation will be at the expense of performance.\n                 * The default value of `2` is usually very adequate.\n                 *\n                 * @property constraintIterations\n                 * @type number\n                 * @default 2\n                 */\n\n                /**\n                 * A flag that specifies whether the engine should allow sleeping via the `Matter.Sleeping` module.\n                 * Sleeping can improve stability and performance, but often at the expense of accuracy.\n                 *\n                 * @property enableSleeping\n                 * @type boolean\n                 * @default false\n                 */\n\n                /**\n                 * An `Object` containing properties regarding the timing systems of the engine. \n                 *\n                 * @property timing\n                 * @type object\n                 */\n\n                /**\n                 * A `Number` that specifies the global scaling factor of time for all bodies.\n                 * A value of `0` freezes the simulation.\n                 * A value of `0.1` gives a slow-motion effect.\n                 * A value of `1.2` gives a speed-up effect.\n                 *\n                 * @property timing.timeScale\n                 * @type number\n                 * @default 1\n                 */\n\n                /**\n                 * A `Number` that specifies the current simulation-time in milliseconds starting from `0`. \n                 * It is incremented on every `Engine.update` by the given `delta` argument. \n                 *\n                 * @property timing.timestamp\n                 * @type number\n                 * @default 0\n                 */\n\n                /**\n                 * An instance of a `Render` controller. The default value is a `Matter.Render` instance created by `Engine.create`.\n                 * One may also develop a custom renderer module based on `Matter.Render` and pass an instance of it to `Engine.create` via `options.render`.\n                 *\n                 * A minimal custom renderer object must define at least three functions: `create`, `clear` and `world` (see `Matter.Render`).\n                 * It is also possible to instead pass the _module_ reference via `options.render.controller` and `Engine.create` will instantiate one for you.\n                 *\n                 * @property render\n                 * @type render\n                 * @deprecated see Demo.js for an example of creating a renderer\n                 * @default a Matter.Render instance\n                 */\n\n                /**\n                 * An instance of a broadphase controller. The default value is a `Matter.Grid` instance created by `Engine.create`.\n                 *\n                 * @property broadphase\n                 * @type grid\n                 * @default a Matter.Grid instance\n                 */\n\n                /**\n                 * A `World` composite object that will contain all simulated bodies and constraints.\n                 *\n                 * @property world\n                 * @type world\n                 * @default a Matter.World instance\n                 */\n\n                /**\n                 * An object reserved for storing plugin-specific properties.\n                 *\n                 * @property plugin\n                 * @type {}\n                 */\n            })();\n        }, { \"../body/Body\": 1, \"../body/Composite\": 2, \"../body/World\": 3, \"../collision/Grid\": 6, \"../collision/Pairs\": 8, \"../collision/Resolver\": 10, \"../constraint/Constraint\": 12, \"../render/Render\": 31, \"./Common\": 14, \"./Events\": 16, \"./Metrics\": 18, \"./Sleeping\": 22 }], 16: [function (_dereq_, module, exports) {\n            /**\n            * The `Matter.Events` module contains methods to fire and listen to events on other objects.\n            *\n            * See the included usage [examples](https://github.com/liabru/matter-js/tree/master/examples).\n            *\n            * @class Events\n            */\n\n            var Events = {};\n\n            module.exports = Events;\n\n            var Common = _dereq_('./Common');\n\n            (function () {\n\n                /**\n                 * Subscribes a callback function to the given object's `eventName`.\n                 * @method on\n                 * @param {} object\n                 * @param {string} eventNames\n                 * @param {function} callback\n                 */\n                Events.on = function (object, eventNames, callback) {\n                    var names = eventNames.split(' '),\n                        name;\n\n                    for (var i = 0; i < names.length; i++) {\n                        name = names[i];\n                        object.events = object.events || {};\n                        object.events[name] = object.events[name] || [];\n                        object.events[name].push(callback);\n                    }\n\n                    return callback;\n                };\n\n                /**\n                 * Removes the given event callback. If no callback, clears all callbacks in `eventNames`. If no `eventNames`, clears all events.\n                 * @method off\n                 * @param {} object\n                 * @param {string} eventNames\n                 * @param {function} callback\n                 */\n                Events.off = function (object, eventNames, callback) {\n                    if (!eventNames) {\n                        object.events = {};\n                        return;\n                    }\n\n                    // handle Events.off(object, callback)\n                    if (typeof eventNames === 'function') {\n                        callback = eventNames;\n                        eventNames = Common.keys(object.events).join(' ');\n                    }\n\n                    var names = eventNames.split(' ');\n\n                    for (var i = 0; i < names.length; i++) {\n                        var callbacks = object.events[names[i]],\n                            newCallbacks = [];\n\n                        if (callback && callbacks) {\n                            for (var j = 0; j < callbacks.length; j++) {\n                                if (callbacks[j] !== callback) newCallbacks.push(callbacks[j]);\n                            }\n                        }\n\n                        object.events[names[i]] = newCallbacks;\n                    }\n                };\n\n                /**\n                 * Fires all the callbacks subscribed to the given object's `eventName`, in the order they subscribed, if any.\n                 * @method trigger\n                 * @param {} object\n                 * @param {string} eventNames\n                 * @param {} event\n                 */\n                Events.trigger = function (object, eventNames, event) {\n                    var names, name, callbacks, eventClone;\n\n                    if (object.events) {\n                        if (!event) event = {};\n\n                        names = eventNames.split(' ');\n\n                        for (var i = 0; i < names.length; i++) {\n                            name = names[i];\n                            callbacks = object.events[name];\n\n                            if (callbacks) {\n                                eventClone = Common.clone(event, false);\n                                eventClone.name = name;\n                                eventClone.source = object;\n\n                                for (var j = 0; j < callbacks.length; j++) {\n                                    callbacks[j].apply(object, [eventClone]);\n                                }\n                            }\n                        }\n                    }\n                };\n            })();\n        }, { \"./Common\": 14 }], 17: [function (_dereq_, module, exports) {\n            /**\n            * The `Matter` module is the top level namespace. It also includes a function for installing plugins on top of the library.\n            *\n            * @class Matter\n            */\n\n            var Matter = {};\n\n            module.exports = Matter;\n\n            var Plugin = _dereq_('./Plugin');\n            var Common = _dereq_('./Common');\n\n            (function () {\n\n                /**\n                 * The library name.\n                 * @property name\n                 * @readOnly\n                 * @type {String}\n                 */\n                Matter.name = 'matter-js';\n\n                /**\n                 * The library version.\n                 * @property version\n                 * @readOnly\n                 * @type {String}\n                 */\n                Matter.version = '0.14.1';\n\n                /**\n                 * A list of plugin dependencies to be installed. These are normally set and installed through `Matter.use`.\n                 * Alternatively you may set `Matter.uses` manually and install them by calling `Plugin.use(Matter)`.\n                 * @property uses\n                 * @type {Array}\n                 */\n                Matter.uses = [];\n\n                /**\n                 * The plugins that have been installed through `Matter.Plugin.install`. Read only.\n                 * @property used\n                 * @readOnly\n                 * @type {Array}\n                 */\n                Matter.used = [];\n\n                /**\n                 * Installs the given plugins on the `Matter` namespace.\n                 * This is a short-hand for `Plugin.use`, see it for more information.\n                 * Call this function once at the start of your code, with all of the plugins you wish to install as arguments.\n                 * Avoid calling this function multiple times unless you intend to manually control installation order.\n                 * @method use\n                 * @param ...plugin {Function} The plugin(s) to install on `base` (multi-argument).\n                 */\n                Matter.use = function () {\n                    Plugin.use(Matter, Array.prototype.slice.call(arguments));\n                };\n\n                /**\n                 * Chains a function to excute before the original function on the given `path` relative to `Matter`.\n                 * See also docs for `Common.chain`.\n                 * @method before\n                 * @param {string} path The path relative to `Matter`\n                 * @param {function} func The function to chain before the original\n                 * @return {function} The chained function that replaced the original\n                 */\n                Matter.before = function (path, func) {\n                    path = path.replace(/^Matter./, '');\n                    return Common.chainPathBefore(Matter, path, func);\n                };\n\n                /**\n                 * Chains a function to excute after the original function on the given `path` relative to `Matter`.\n                 * See also docs for `Common.chain`.\n                 * @method after\n                 * @param {string} path The path relative to `Matter`\n                 * @param {function} func The function to chain after the original\n                 * @return {function} The chained function that replaced the original\n                 */\n                Matter.after = function (path, func) {\n                    path = path.replace(/^Matter./, '');\n                    return Common.chainPathAfter(Matter, path, func);\n                };\n            })();\n        }, { \"./Common\": 14, \"./Plugin\": 20 }], 18: [function (_dereq_, module, exports) {}, { \"../body/Composite\": 2, \"./Common\": 14 }], 19: [function (_dereq_, module, exports) {\n            /**\n            * The `Matter.Mouse` module contains methods for creating and manipulating mouse inputs.\n            *\n            * @class Mouse\n            */\n\n            var Mouse = {};\n\n            module.exports = Mouse;\n\n            var Common = _dereq_('../core/Common');\n\n            (function () {\n\n                /**\n                 * Creates a mouse input.\n                 * @method create\n                 * @param {HTMLElement} element\n                 * @return {mouse} A new mouse\n                 */\n                Mouse.create = function (element) {\n                    var mouse = {};\n\n                    if (!element) {\n                        Common.log('Mouse.create: element was undefined, defaulting to document.body', 'warn');\n                    }\n\n                    mouse.element = element || document.body;\n                    mouse.absolute = { x: 0, y: 0 };\n                    mouse.position = { x: 0, y: 0 };\n                    mouse.mousedownPosition = { x: 0, y: 0 };\n                    mouse.mouseupPosition = { x: 0, y: 0 };\n                    mouse.offset = { x: 0, y: 0 };\n                    mouse.scale = { x: 1, y: 1 };\n                    mouse.wheelDelta = 0;\n                    mouse.button = -1;\n                    mouse.pixelRatio = mouse.element.getAttribute('data-pixel-ratio') || 1;\n\n                    mouse.sourceEvents = {\n                        mousemove: null,\n                        mousedown: null,\n                        mouseup: null,\n                        mousewheel: null\n                    };\n\n                    mouse.mousemove = function (event) {\n                        var position = Mouse._getRelativeMousePosition(event, mouse.element, mouse.pixelRatio),\n                            touches = event.changedTouches;\n\n                        if (touches) {\n                            mouse.button = 0;\n                            event.preventDefault();\n                        }\n\n                        mouse.absolute.x = position.x;\n                        mouse.absolute.y = position.y;\n                        mouse.position.x = mouse.absolute.x * mouse.scale.x + mouse.offset.x;\n                        mouse.position.y = mouse.absolute.y * mouse.scale.y + mouse.offset.y;\n                        mouse.sourceEvents.mousemove = event;\n                    };\n\n                    mouse.mousedown = function (event) {\n                        var position = Mouse._getRelativeMousePosition(event, mouse.element, mouse.pixelRatio),\n                            touches = event.changedTouches;\n\n                        if (touches) {\n                            mouse.button = 0;\n                            event.preventDefault();\n                        } else {\n                            mouse.button = event.button;\n                        }\n\n                        mouse.absolute.x = position.x;\n                        mouse.absolute.y = position.y;\n                        mouse.position.x = mouse.absolute.x * mouse.scale.x + mouse.offset.x;\n                        mouse.position.y = mouse.absolute.y * mouse.scale.y + mouse.offset.y;\n                        mouse.mousedownPosition.x = mouse.position.x;\n                        mouse.mousedownPosition.y = mouse.position.y;\n                        mouse.sourceEvents.mousedown = event;\n                    };\n\n                    mouse.mouseup = function (event) {\n                        var position = Mouse._getRelativeMousePosition(event, mouse.element, mouse.pixelRatio),\n                            touches = event.changedTouches;\n\n                        if (touches) {\n                            event.preventDefault();\n                        }\n\n                        mouse.button = -1;\n                        mouse.absolute.x = position.x;\n                        mouse.absolute.y = position.y;\n                        mouse.position.x = mouse.absolute.x * mouse.scale.x + mouse.offset.x;\n                        mouse.position.y = mouse.absolute.y * mouse.scale.y + mouse.offset.y;\n                        mouse.mouseupPosition.x = mouse.position.x;\n                        mouse.mouseupPosition.y = mouse.position.y;\n                        mouse.sourceEvents.mouseup = event;\n                    };\n\n                    mouse.mousewheel = function (event) {\n                        mouse.wheelDelta = Math.max(-1, Math.min(1, event.wheelDelta || -event.detail));\n                        event.preventDefault();\n                    };\n\n                    Mouse.setElement(mouse, mouse.element);\n\n                    return mouse;\n                };\n\n                /**\n                 * Sets the element the mouse is bound to (and relative to).\n                 * @method setElement\n                 * @param {mouse} mouse\n                 * @param {HTMLElement} element\n                 */\n                Mouse.setElement = function (mouse, element) {\n                    mouse.element = element;\n\n                    element.addEventListener('mousemove', mouse.mousemove);\n                    element.addEventListener('mousedown', mouse.mousedown);\n                    element.addEventListener('mouseup', mouse.mouseup);\n\n                    element.addEventListener('mousewheel', mouse.mousewheel);\n                    element.addEventListener('DOMMouseScroll', mouse.mousewheel);\n\n                    element.addEventListener('touchmove', mouse.mousemove);\n                    element.addEventListener('touchstart', mouse.mousedown);\n                    element.addEventListener('touchend', mouse.mouseup);\n                };\n\n                /**\n                 * Clears all captured source events.\n                 * @method clearSourceEvents\n                 * @param {mouse} mouse\n                 */\n                Mouse.clearSourceEvents = function (mouse) {\n                    mouse.sourceEvents.mousemove = null;\n                    mouse.sourceEvents.mousedown = null;\n                    mouse.sourceEvents.mouseup = null;\n                    mouse.sourceEvents.mousewheel = null;\n                    mouse.wheelDelta = 0;\n                };\n\n                /**\n                 * Sets the mouse position offset.\n                 * @method setOffset\n                 * @param {mouse} mouse\n                 * @param {vector} offset\n                 */\n                Mouse.setOffset = function (mouse, offset) {\n                    mouse.offset.x = offset.x;\n                    mouse.offset.y = offset.y;\n                    mouse.position.x = mouse.absolute.x * mouse.scale.x + mouse.offset.x;\n                    mouse.position.y = mouse.absolute.y * mouse.scale.y + mouse.offset.y;\n                };\n\n                /**\n                 * Sets the mouse position scale.\n                 * @method setScale\n                 * @param {mouse} mouse\n                 * @param {vector} scale\n                 */\n                Mouse.setScale = function (mouse, scale) {\n                    mouse.scale.x = scale.x;\n                    mouse.scale.y = scale.y;\n                    mouse.position.x = mouse.absolute.x * mouse.scale.x + mouse.offset.x;\n                    mouse.position.y = mouse.absolute.y * mouse.scale.y + mouse.offset.y;\n                };\n\n                /**\n                 * Gets the mouse position relative to an element given a screen pixel ratio.\n                 * @method _getRelativeMousePosition\n                 * @private\n                 * @param {} event\n                 * @param {} element\n                 * @param {number} pixelRatio\n                 * @return {}\n                 */\n                Mouse._getRelativeMousePosition = function (event, element, pixelRatio) {\n                    var elementBounds = element.getBoundingClientRect(),\n                        rootNode = document.documentElement || document.body.parentNode || document.body,\n                        scrollX = window.pageXOffset !== undefined ? window.pageXOffset : rootNode.scrollLeft,\n                        scrollY = window.pageYOffset !== undefined ? window.pageYOffset : rootNode.scrollTop,\n                        touches = event.changedTouches,\n                        x,\n                        y;\n\n                    if (touches) {\n                        x = touches[0].pageX - elementBounds.left - scrollX;\n                        y = touches[0].pageY - elementBounds.top - scrollY;\n                    } else {\n                        x = event.pageX - elementBounds.left - scrollX;\n                        y = event.pageY - elementBounds.top - scrollY;\n                    }\n\n                    return {\n                        x: x / (element.clientWidth / (element.width || element.clientWidth) * pixelRatio),\n                        y: y / (element.clientHeight / (element.height || element.clientHeight) * pixelRatio)\n                    };\n                };\n            })();\n        }, { \"../core/Common\": 14 }], 20: [function (_dereq_, module, exports) {\n            /**\n            * The `Matter.Plugin` module contains functions for registering and installing plugins on modules.\n            *\n            * @class Plugin\n            */\n\n            var Plugin = {};\n\n            module.exports = Plugin;\n\n            var Common = _dereq_('./Common');\n\n            (function () {\n\n                Plugin._registry = {};\n\n                /**\n                 * Registers a plugin object so it can be resolved later by name.\n                 * @method register\n                 * @param plugin {} The plugin to register.\n                 * @return {object} The plugin.\n                 */\n                Plugin.register = function (plugin) {\n                    if (!Plugin.isPlugin(plugin)) {\n                        Common.warn('Plugin.register:', Plugin.toString(plugin), 'does not implement all required fields.');\n                    }\n\n                    if (plugin.name in Plugin._registry) {\n                        var registered = Plugin._registry[plugin.name],\n                            pluginVersion = Plugin.versionParse(plugin.version).number,\n                            registeredVersion = Plugin.versionParse(registered.version).number;\n\n                        if (pluginVersion > registeredVersion) {\n                            Common.warn('Plugin.register:', Plugin.toString(registered), 'was upgraded to', Plugin.toString(plugin));\n                            Plugin._registry[plugin.name] = plugin;\n                        } else if (pluginVersion < registeredVersion) {\n                            Common.warn('Plugin.register:', Plugin.toString(registered), 'can not be downgraded to', Plugin.toString(plugin));\n                        } else if (plugin !== registered) {\n                            Common.warn('Plugin.register:', Plugin.toString(plugin), 'is already registered to different plugin object');\n                        }\n                    } else {\n                        Plugin._registry[plugin.name] = plugin;\n                    }\n\n                    return plugin;\n                };\n\n                /**\n                 * Resolves a dependency to a plugin object from the registry if it exists. \n                 * The `dependency` may contain a version, but only the name matters when resolving.\n                 * @method resolve\n                 * @param dependency {string} The dependency.\n                 * @return {object} The plugin if resolved, otherwise `undefined`.\n                 */\n                Plugin.resolve = function (dependency) {\n                    return Plugin._registry[Plugin.dependencyParse(dependency).name];\n                };\n\n                /**\n                 * Returns a pretty printed plugin name and version.\n                 * @method toString\n                 * @param plugin {} The plugin.\n                 * @return {string} Pretty printed plugin name and version.\n                 */\n                Plugin.toString = function (plugin) {\n                    return typeof plugin === 'string' ? plugin : (plugin.name || 'anonymous') + '@' + (plugin.version || plugin.range || '0.0.0');\n                };\n\n                /**\n                 * Returns `true` if the object meets the minimum standard to be considered a plugin.\n                 * This means it must define the following properties:\n                 * - `name`\n                 * - `version`\n                 * - `install`\n                 * @method isPlugin\n                 * @param obj {} The obj to test.\n                 * @return {boolean} `true` if the object can be considered a plugin otherwise `false`.\n                 */\n                Plugin.isPlugin = function (obj) {\n                    return obj && obj.name && obj.version && obj.install;\n                };\n\n                /**\n                 * Returns `true` if a plugin with the given `name` been installed on `module`.\n                 * @method isUsed\n                 * @param module {} The module.\n                 * @param name {string} The plugin name.\n                 * @return {boolean} `true` if a plugin with the given `name` been installed on `module`, otherwise `false`.\n                 */\n                Plugin.isUsed = function (module, name) {\n                    return module.used.indexOf(name) > -1;\n                };\n\n                /**\n                 * Returns `true` if `plugin.for` is applicable to `module` by comparing against `module.name` and `module.version`.\n                 * If `plugin.for` is not specified then it is assumed to be applicable.\n                 * The value of `plugin.for` is a string of the format `'module-name'` or `'module-name@version'`.\n                 * @method isFor\n                 * @param plugin {} The plugin.\n                 * @param module {} The module.\n                 * @return {boolean} `true` if `plugin.for` is applicable to `module`, otherwise `false`.\n                 */\n                Plugin.isFor = function (plugin, module) {\n                    var parsed = plugin.for && Plugin.dependencyParse(plugin.for);\n                    return !plugin.for || module.name === parsed.name && Plugin.versionSatisfies(module.version, parsed.range);\n                };\n\n                /**\n                 * Installs the plugins by calling `plugin.install` on each plugin specified in `plugins` if passed, otherwise `module.uses`.\n                 * For installing plugins on `Matter` see the convenience function `Matter.use`.\n                 * Plugins may be specified either by their name or a reference to the plugin object.\n                 * Plugins themselves may specify further dependencies, but each plugin is installed only once.\n                 * Order is important, a topological sort is performed to find the best resulting order of installation.\n                 * This sorting attempts to satisfy every dependency's requested ordering, but may not be exact in all cases.\n                 * This function logs the resulting status of each dependency in the console, along with any warnings.\n                 * - A green tick ✅ indicates a dependency was resolved and installed.\n                 * - An orange diamond 🔶 indicates a dependency was resolved but a warning was thrown for it or one if its dependencies.\n                 * - A red cross ❌ indicates a dependency could not be resolved.\n                 * Avoid calling this function multiple times on the same module unless you intend to manually control installation order.\n                 * @method use\n                 * @param module {} The module install plugins on.\n                 * @param [plugins=module.uses] {} The plugins to install on module (optional, defaults to `module.uses`).\n                 */\n                Plugin.use = function (module, plugins) {\n                    module.uses = (module.uses || []).concat(plugins || []);\n\n                    if (module.uses.length === 0) {\n                        Common.warn('Plugin.use:', Plugin.toString(module), 'does not specify any dependencies to install.');\n                        return;\n                    }\n\n                    var dependencies = Plugin.dependencies(module),\n                        sortedDependencies = Common.topologicalSort(dependencies),\n                        status = [];\n\n                    for (var i = 0; i < sortedDependencies.length; i += 1) {\n                        if (sortedDependencies[i] === module.name) {\n                            continue;\n                        }\n\n                        var plugin = Plugin.resolve(sortedDependencies[i]);\n\n                        if (!plugin) {\n                            status.push('❌ ' + sortedDependencies[i]);\n                            continue;\n                        }\n\n                        if (Plugin.isUsed(module, plugin.name)) {\n                            continue;\n                        }\n\n                        if (!Plugin.isFor(plugin, module)) {\n                            Common.warn('Plugin.use:', Plugin.toString(plugin), 'is for', plugin.for, 'but installed on', Plugin.toString(module) + '.');\n                            plugin._warned = true;\n                        }\n\n                        if (plugin.install) {\n                            plugin.install(module);\n                        } else {\n                            Common.warn('Plugin.use:', Plugin.toString(plugin), 'does not specify an install function.');\n                            plugin._warned = true;\n                        }\n\n                        if (plugin._warned) {\n                            status.push('🔶 ' + Plugin.toString(plugin));\n                            delete plugin._warned;\n                        } else {\n                            status.push('✅ ' + Plugin.toString(plugin));\n                        }\n\n                        module.used.push(plugin.name);\n                    }\n\n                    if (status.length > 0) {\n                        Common.info(status.join('  '));\n                    }\n                };\n\n                /**\n                 * Recursively finds all of a module's dependencies and returns a flat dependency graph.\n                 * @method dependencies\n                 * @param module {} The module.\n                 * @return {object} A dependency graph.\n                 */\n                Plugin.dependencies = function (module, tracked) {\n                    var parsedBase = Plugin.dependencyParse(module),\n                        name = parsedBase.name;\n\n                    tracked = tracked || {};\n\n                    if (name in tracked) {\n                        return;\n                    }\n\n                    module = Plugin.resolve(module) || module;\n\n                    tracked[name] = Common.map(module.uses || [], function (dependency) {\n                        if (Plugin.isPlugin(dependency)) {\n                            Plugin.register(dependency);\n                        }\n\n                        var parsed = Plugin.dependencyParse(dependency),\n                            resolved = Plugin.resolve(dependency);\n\n                        if (resolved && !Plugin.versionSatisfies(resolved.version, parsed.range)) {\n                            Common.warn('Plugin.dependencies:', Plugin.toString(resolved), 'does not satisfy', Plugin.toString(parsed), 'used by', Plugin.toString(parsedBase) + '.');\n\n                            resolved._warned = true;\n                            module._warned = true;\n                        } else if (!resolved) {\n                            Common.warn('Plugin.dependencies:', Plugin.toString(dependency), 'used by', Plugin.toString(parsedBase), 'could not be resolved.');\n\n                            module._warned = true;\n                        }\n\n                        return parsed.name;\n                    });\n\n                    for (var i = 0; i < tracked[name].length; i += 1) {\n                        Plugin.dependencies(tracked[name][i], tracked);\n                    }\n\n                    return tracked;\n                };\n\n                /**\n                 * Parses a dependency string into its components.\n                 * The `dependency` is a string of the format `'module-name'` or `'module-name@version'`.\n                 * See documentation for `Plugin.versionParse` for a description of the format.\n                 * This function can also handle dependencies that are already resolved (e.g. a module object).\n                 * @method dependencyParse\n                 * @param dependency {string} The dependency of the format `'module-name'` or `'module-name@version'`.\n                 * @return {object} The dependency parsed into its components.\n                 */\n                Plugin.dependencyParse = function (dependency) {\n                    if (Common.isString(dependency)) {\n                        var pattern = /^[\\w-]+(@(\\*|[\\^~]?\\d+\\.\\d+\\.\\d+(-[0-9A-Za-z-]+)?))?$/;\n\n                        if (!pattern.test(dependency)) {\n                            Common.warn('Plugin.dependencyParse:', dependency, 'is not a valid dependency string.');\n                        }\n\n                        return {\n                            name: dependency.split('@')[0],\n                            range: dependency.split('@')[1] || '*'\n                        };\n                    }\n\n                    return {\n                        name: dependency.name,\n                        range: dependency.range || dependency.version\n                    };\n                };\n\n                /**\n                 * Parses a version string into its components.  \n                 * Versions are strictly of the format `x.y.z` (as in [semver](http://semver.org/)).\n                 * Versions may optionally have a prerelease tag in the format `x.y.z-alpha`.\n                 * Ranges are a strict subset of [npm ranges](https://docs.npmjs.com/misc/semver#advanced-range-syntax).\n                 * Only the following range types are supported:\n                 * - Tilde ranges e.g. `~1.2.3`\n                 * - Caret ranges e.g. `^1.2.3`\n                 * - Exact version e.g. `1.2.3`\n                 * - Any version `*`\n                 * @method versionParse\n                 * @param range {string} The version string.\n                 * @return {object} The version range parsed into its components.\n                 */\n                Plugin.versionParse = function (range) {\n                    var pattern = /^\\*|[\\^~]?\\d+\\.\\d+\\.\\d+(-[0-9A-Za-z-]+)?$/;\n\n                    if (!pattern.test(range)) {\n                        Common.warn('Plugin.versionParse:', range, 'is not a valid version or range.');\n                    }\n\n                    var identifiers = range.split('-');\n                    range = identifiers[0];\n\n                    var isRange = isNaN(Number(range[0])),\n                        version = isRange ? range.substr(1) : range,\n                        parts = Common.map(version.split('.'), function (part) {\n                        return Number(part);\n                    });\n\n                    return {\n                        isRange: isRange,\n                        version: version,\n                        range: range,\n                        operator: isRange ? range[0] : '',\n                        parts: parts,\n                        prerelease: identifiers[1],\n                        number: parts[0] * 1e8 + parts[1] * 1e4 + parts[2]\n                    };\n                };\n\n                /**\n                 * Returns `true` if `version` satisfies the given `range`.\n                 * See documentation for `Plugin.versionParse` for a description of the format.\n                 * If a version or range is not specified, then any version (`*`) is assumed to satisfy.\n                 * @method versionSatisfies\n                 * @param version {string} The version string.\n                 * @param range {string} The range string.\n                 * @return {boolean} `true` if `version` satisfies `range`, otherwise `false`.\n                 */\n                Plugin.versionSatisfies = function (version, range) {\n                    range = range || '*';\n\n                    var rangeParsed = Plugin.versionParse(range),\n                        rangeParts = rangeParsed.parts,\n                        versionParsed = Plugin.versionParse(version),\n                        versionParts = versionParsed.parts;\n\n                    if (rangeParsed.isRange) {\n                        if (rangeParsed.operator === '*' || version === '*') {\n                            return true;\n                        }\n\n                        if (rangeParsed.operator === '~') {\n                            return versionParts[0] === rangeParts[0] && versionParts[1] === rangeParts[1] && versionParts[2] >= rangeParts[2];\n                        }\n\n                        if (rangeParsed.operator === '^') {\n                            if (rangeParts[0] > 0) {\n                                return versionParts[0] === rangeParts[0] && versionParsed.number >= rangeParsed.number;\n                            }\n\n                            if (rangeParts[1] > 0) {\n                                return versionParts[1] === rangeParts[1] && versionParts[2] >= rangeParts[2];\n                            }\n\n                            return versionParts[2] === rangeParts[2];\n                        }\n                    }\n\n                    return version === range || version === '*';\n                };\n            })();\n        }, { \"./Common\": 14 }], 21: [function (_dereq_, module, exports) {\n            /**\n            * The `Matter.Runner` module is an optional utility which provides a game loop, \n            * that handles continuously updating a `Matter.Engine` for you within a browser.\n            * It is intended for development and debugging purposes, but may also be suitable for simple games.\n            * If you are using your own game loop instead, then you do not need the `Matter.Runner` module.\n            * Instead just call `Engine.update(engine, delta)` in your own loop.\n            *\n            * See the included usage [examples](https://github.com/liabru/matter-js/tree/master/examples).\n            *\n            * @class Runner\n            */\n\n            var Runner = {};\n\n            module.exports = Runner;\n\n            var Events = _dereq_('./Events');\n            var Engine = _dereq_('./Engine');\n            var Common = _dereq_('./Common');\n\n            (function () {\n\n                var _requestAnimationFrame, _cancelAnimationFrame;\n\n                if (typeof window !== 'undefined') {\n                    _requestAnimationFrame = window.requestAnimationFrame || window.webkitRequestAnimationFrame || window.mozRequestAnimationFrame || window.msRequestAnimationFrame;\n\n                    _cancelAnimationFrame = window.cancelAnimationFrame || window.mozCancelAnimationFrame || window.webkitCancelAnimationFrame || window.msCancelAnimationFrame;\n                }\n\n                if (!_requestAnimationFrame) {\n                    var _frameTimeout;\n\n                    _requestAnimationFrame = function _requestAnimationFrame(callback) {\n                        _frameTimeout = setTimeout(function () {\n                            callback(Common.now());\n                        }, 1000 / 60);\n                    };\n\n                    _cancelAnimationFrame = function _cancelAnimationFrame() {\n                        clearTimeout(_frameTimeout);\n                    };\n                }\n\n                /**\n                 * Creates a new Runner. The options parameter is an object that specifies any properties you wish to override the defaults.\n                 * @method create\n                 * @param {} options\n                 */\n                Runner.create = function (options) {\n                    var defaults = {\n                        fps: 60,\n                        correction: 1,\n                        deltaSampleSize: 60,\n                        counterTimestamp: 0,\n                        frameCounter: 0,\n                        deltaHistory: [],\n                        timePrev: null,\n                        timeScalePrev: 1,\n                        frameRequestId: null,\n                        isFixed: false,\n                        enabled: true\n                    };\n\n                    var runner = Common.extend(defaults, options);\n\n                    runner.delta = runner.delta || 1000 / runner.fps;\n                    runner.deltaMin = runner.deltaMin || 1000 / runner.fps;\n                    runner.deltaMax = runner.deltaMax || 1000 / (runner.fps * 0.5);\n                    runner.fps = 1000 / runner.delta;\n\n                    return runner;\n                };\n\n                /**\n                 * Continuously ticks a `Matter.Engine` by calling `Runner.tick` on the `requestAnimationFrame` event.\n                 * @method run\n                 * @param {engine} engine\n                 */\n                Runner.run = function (runner, engine) {\n                    // create runner if engine is first argument\n                    if (typeof runner.positionIterations !== 'undefined') {\n                        engine = runner;\n                        runner = Runner.create();\n                    }\n\n                    (function render(time) {\n                        runner.frameRequestId = _requestAnimationFrame(render);\n\n                        if (time && runner.enabled) {\n                            Runner.tick(runner, engine, time);\n                        }\n                    })();\n\n                    return runner;\n                };\n\n                /**\n                 * A game loop utility that updates the engine and renderer by one step (a 'tick').\n                 * Features delta smoothing, time correction and fixed or dynamic timing.\n                 * Triggers `beforeTick`, `tick` and `afterTick` events on the engine.\n                 * Consider just `Engine.update(engine, delta)` if you're using your own loop.\n                 * @method tick\n                 * @param {runner} runner\n                 * @param {engine} engine\n                 * @param {number} time\n                 */\n                Runner.tick = function (runner, engine, time) {\n                    var timing = engine.timing,\n                        correction = 1,\n                        delta;\n\n                    // create an event object\n                    var event = {\n                        timestamp: timing.timestamp\n                    };\n\n                    Events.trigger(runner, 'beforeTick', event);\n                    Events.trigger(engine, 'beforeTick', event); // @deprecated\n\n                    if (runner.isFixed) {\n                        // fixed timestep\n                        delta = runner.delta;\n                    } else {\n                        // dynamic timestep based on wall clock between calls\n                        delta = time - runner.timePrev || runner.delta;\n                        runner.timePrev = time;\n\n                        // optimistically filter delta over a few frames, to improve stability\n                        runner.deltaHistory.push(delta);\n                        runner.deltaHistory = runner.deltaHistory.slice(-runner.deltaSampleSize);\n                        delta = Math.min.apply(null, runner.deltaHistory);\n\n                        // limit delta\n                        delta = delta < runner.deltaMin ? runner.deltaMin : delta;\n                        delta = delta > runner.deltaMax ? runner.deltaMax : delta;\n\n                        // correction for delta\n                        correction = delta / runner.delta;\n\n                        // update engine timing object\n                        runner.delta = delta;\n                    }\n\n                    // time correction for time scaling\n                    if (runner.timeScalePrev !== 0) correction *= timing.timeScale / runner.timeScalePrev;\n\n                    if (timing.timeScale === 0) correction = 0;\n\n                    runner.timeScalePrev = timing.timeScale;\n                    runner.correction = correction;\n\n                    // fps counter\n                    runner.frameCounter += 1;\n                    if (time - runner.counterTimestamp >= 1000) {\n                        runner.fps = runner.frameCounter * ((time - runner.counterTimestamp) / 1000);\n                        runner.counterTimestamp = time;\n                        runner.frameCounter = 0;\n                    }\n\n                    Events.trigger(runner, 'tick', event);\n                    Events.trigger(engine, 'tick', event); // @deprecated\n\n                    // if world has been modified, clear the render scene graph\n                    if (engine.world.isModified && engine.render && engine.render.controller && engine.render.controller.clear) {\n                        engine.render.controller.clear(engine.render); // @deprecated\n                    }\n\n                    // update\n                    Events.trigger(runner, 'beforeUpdate', event);\n                    Engine.update(engine, delta, correction);\n                    Events.trigger(runner, 'afterUpdate', event);\n\n                    // render\n                    // @deprecated\n                    if (engine.render && engine.render.controller) {\n                        Events.trigger(runner, 'beforeRender', event);\n                        Events.trigger(engine, 'beforeRender', event); // @deprecated\n\n                        engine.render.controller.world(engine.render);\n\n                        Events.trigger(runner, 'afterRender', event);\n                        Events.trigger(engine, 'afterRender', event); // @deprecated\n                    }\n\n                    Events.trigger(runner, 'afterTick', event);\n                    Events.trigger(engine, 'afterTick', event); // @deprecated\n                };\n\n                /**\n                 * Ends execution of `Runner.run` on the given `runner`, by canceling the animation frame request event loop.\n                 * If you wish to only temporarily pause the engine, see `engine.enabled` instead.\n                 * @method stop\n                 * @param {runner} runner\n                 */\n                Runner.stop = function (runner) {\n                    _cancelAnimationFrame(runner.frameRequestId);\n                };\n\n                /**\n                 * Alias for `Runner.run`.\n                 * @method start\n                 * @param {runner} runner\n                 * @param {engine} engine\n                 */\n                Runner.start = function (runner, engine) {\n                    Runner.run(runner, engine);\n                };\n\n                /*\n                *\n                *  Events Documentation\n                *\n                */\n\n                /**\n                * Fired at the start of a tick, before any updates to the engine or timing\n                *\n                * @event beforeTick\n                * @param {} event An event object\n                * @param {number} event.timestamp The engine.timing.timestamp of the event\n                * @param {} event.source The source object of the event\n                * @param {} event.name The name of the event\n                */\n\n                /**\n                * Fired after engine timing updated, but just before update\n                *\n                * @event tick\n                * @param {} event An event object\n                * @param {number} event.timestamp The engine.timing.timestamp of the event\n                * @param {} event.source The source object of the event\n                * @param {} event.name The name of the event\n                */\n\n                /**\n                * Fired at the end of a tick, after engine update and after rendering\n                *\n                * @event afterTick\n                * @param {} event An event object\n                * @param {number} event.timestamp The engine.timing.timestamp of the event\n                * @param {} event.source The source object of the event\n                * @param {} event.name The name of the event\n                */\n\n                /**\n                * Fired before update\n                *\n                * @event beforeUpdate\n                * @param {} event An event object\n                * @param {number} event.timestamp The engine.timing.timestamp of the event\n                * @param {} event.source The source object of the event\n                * @param {} event.name The name of the event\n                */\n\n                /**\n                * Fired after update\n                *\n                * @event afterUpdate\n                * @param {} event An event object\n                * @param {number} event.timestamp The engine.timing.timestamp of the event\n                * @param {} event.source The source object of the event\n                * @param {} event.name The name of the event\n                */\n\n                /**\n                * Fired before rendering\n                *\n                * @event beforeRender\n                * @param {} event An event object\n                * @param {number} event.timestamp The engine.timing.timestamp of the event\n                * @param {} event.source The source object of the event\n                * @param {} event.name The name of the event\n                * @deprecated\n                */\n\n                /**\n                * Fired after rendering\n                *\n                * @event afterRender\n                * @param {} event An event object\n                * @param {number} event.timestamp The engine.timing.timestamp of the event\n                * @param {} event.source The source object of the event\n                * @param {} event.name The name of the event\n                * @deprecated\n                */\n\n                /*\n                *\n                *  Properties Documentation\n                *\n                */\n\n                /**\n                 * A flag that specifies whether the runner is running or not.\n                 *\n                 * @property enabled\n                 * @type boolean\n                 * @default true\n                 */\n\n                /**\n                 * A `Boolean` that specifies if the runner should use a fixed timestep (otherwise it is variable).\n                 * If timing is fixed, then the apparent simulation speed will change depending on the frame rate (but behaviour will be deterministic).\n                 * If the timing is variable, then the apparent simulation speed will be constant (approximately, but at the cost of determininism).\n                 *\n                 * @property isFixed\n                 * @type boolean\n                 * @default false\n                 */\n\n                /**\n                 * A `Number` that specifies the time step between updates in milliseconds.\n                 * If `engine.timing.isFixed` is set to `true`, then `delta` is fixed.\n                 * If it is `false`, then `delta` can dynamically change to maintain the correct apparent simulation speed.\n                 *\n                 * @property delta\n                 * @type number\n                 * @default 1000 / 60\n                 */\n            })();\n        }, { \"./Common\": 14, \"./Engine\": 15, \"./Events\": 16 }], 22: [function (_dereq_, module, exports) {\n            /**\n            * The `Matter.Sleeping` module contains methods to manage the sleeping state of bodies.\n            *\n            * @class Sleeping\n            */\n\n            var Sleeping = {};\n\n            module.exports = Sleeping;\n\n            var Events = _dereq_('./Events');\n\n            (function () {\n\n                Sleeping._motionWakeThreshold = 0.18;\n                Sleeping._motionSleepThreshold = 0.08;\n                Sleeping._minBias = 0.9;\n\n                /**\n                 * Puts bodies to sleep or wakes them up depending on their motion.\n                 * @method update\n                 * @param {body[]} bodies\n                 * @param {number} timeScale\n                 */\n                Sleeping.update = function (bodies, timeScale) {\n                    var timeFactor = timeScale * timeScale * timeScale;\n\n                    // update bodies sleeping status\n                    for (var i = 0; i < bodies.length; i++) {\n                        var body = bodies[i],\n                            motion = body.speed * body.speed + body.angularSpeed * body.angularSpeed;\n\n                        // wake up bodies if they have a force applied\n                        if (body.force.x !== 0 || body.force.y !== 0) {\n                            Sleeping.set(body, false);\n                            continue;\n                        }\n\n                        var minMotion = Math.min(body.motion, motion),\n                            maxMotion = Math.max(body.motion, motion);\n\n                        // biased average motion estimation between frames\n                        body.motion = Sleeping._minBias * minMotion + (1 - Sleeping._minBias) * maxMotion;\n\n                        if (body.sleepThreshold > 0 && body.motion < Sleeping._motionSleepThreshold * timeFactor) {\n                            body.sleepCounter += 1;\n\n                            if (body.sleepCounter >= body.sleepThreshold) Sleeping.set(body, true);\n                        } else if (body.sleepCounter > 0) {\n                            body.sleepCounter -= 1;\n                        }\n                    }\n                };\n\n                /**\n                 * Given a set of colliding pairs, wakes the sleeping bodies involved.\n                 * @method afterCollisions\n                 * @param {pair[]} pairs\n                 * @param {number} timeScale\n                 */\n                Sleeping.afterCollisions = function (pairs, timeScale) {\n                    var timeFactor = timeScale * timeScale * timeScale;\n\n                    // wake up bodies involved in collisions\n                    for (var i = 0; i < pairs.length; i++) {\n                        var pair = pairs[i];\n\n                        // don't wake inactive pairs\n                        if (!pair.isActive) continue;\n\n                        var collision = pair.collision,\n                            bodyA = collision.bodyA.parent,\n                            bodyB = collision.bodyB.parent;\n\n                        // don't wake if at least one body is static\n                        if (bodyA.isSleeping && bodyB.isSleeping || bodyA.isStatic || bodyB.isStatic) continue;\n\n                        if (bodyA.isSleeping || bodyB.isSleeping) {\n                            var sleepingBody = bodyA.isSleeping && !bodyA.isStatic ? bodyA : bodyB,\n                                movingBody = sleepingBody === bodyA ? bodyB : bodyA;\n\n                            if (!sleepingBody.isStatic && movingBody.motion > Sleeping._motionWakeThreshold * timeFactor) {\n                                Sleeping.set(sleepingBody, false);\n                            }\n                        }\n                    }\n                };\n\n                /**\n                 * Set a body as sleeping or awake.\n                 * @method set\n                 * @param {body} body\n                 * @param {boolean} isSleeping\n                 */\n                Sleeping.set = function (body, isSleeping) {\n                    var wasSleeping = body.isSleeping;\n\n                    if (isSleeping) {\n                        body.isSleeping = true;\n                        body.sleepCounter = body.sleepThreshold;\n\n                        body.positionImpulse.x = 0;\n                        body.positionImpulse.y = 0;\n\n                        body.positionPrev.x = body.position.x;\n                        body.positionPrev.y = body.position.y;\n\n                        body.anglePrev = body.angle;\n                        body.speed = 0;\n                        body.angularSpeed = 0;\n                        body.motion = 0;\n\n                        if (!wasSleeping) {\n                            Events.trigger(body, 'sleepStart');\n                        }\n                    } else {\n                        body.isSleeping = false;\n                        body.sleepCounter = 0;\n\n                        if (wasSleeping) {\n                            Events.trigger(body, 'sleepEnd');\n                        }\n                    }\n                };\n            })();\n        }, { \"./Events\": 16 }], 23: [function (_dereq_, module, exports) {\n            (function (global) {\n                /**\n                * The `Matter.Bodies` module contains factory methods for creating rigid body models \n                * with commonly used body configurations (such as rectangles, circles and other polygons).\n                *\n                * See the included usage [examples](https://github.com/liabru/matter-js/tree/master/examples).\n                *\n                * @class Bodies\n                */\n\n                // TODO: true circle bodies\n\n                var Bodies = {};\n\n                module.exports = Bodies;\n\n                var Vertices = _dereq_('../geometry/Vertices');\n                var Common = _dereq_('../core/Common');\n                var Body = _dereq_('../body/Body');\n                var Bounds = _dereq_('../geometry/Bounds');\n                var Vector = _dereq_('../geometry/Vector');\n                var decomp = typeof window !== \"undefined\" ? window['decomp'] : typeof global !== \"undefined\" ? global['decomp'] : null;\n\n                (function () {\n\n                    /**\n                     * Creates a new rigid body model with a rectangle hull. \n                     * The options parameter is an object that specifies any properties you wish to override the defaults.\n                     * See the properties section of the `Matter.Body` module for detailed information on what you can pass via the `options` object.\n                     * @method rectangle\n                     * @param {number} x\n                     * @param {number} y\n                     * @param {number} width\n                     * @param {number} height\n                     * @param {object} [options]\n                     * @return {body} A new rectangle body\n                     */\n                    Bodies.rectangle = function (x, y, width, height, options) {\n                        options = options || {};\n\n                        var rectangle = {\n                            label: 'Rectangle Body',\n                            position: { x: x, y: y },\n                            vertices: Vertices.fromPath('L 0 0 L ' + width + ' 0 L ' + width + ' ' + height + ' L 0 ' + height)\n                        };\n\n                        if (options.chamfer) {\n                            var chamfer = options.chamfer;\n                            rectangle.vertices = Vertices.chamfer(rectangle.vertices, chamfer.radius, chamfer.quality, chamfer.qualityMin, chamfer.qualityMax);\n                            delete options.chamfer;\n                        }\n\n                        return Body.create(Common.extend({}, rectangle, options));\n                    };\n\n                    /**\n                     * Creates a new rigid body model with a trapezoid hull. \n                     * The options parameter is an object that specifies any properties you wish to override the defaults.\n                     * See the properties section of the `Matter.Body` module for detailed information on what you can pass via the `options` object.\n                     * @method trapezoid\n                     * @param {number} x\n                     * @param {number} y\n                     * @param {number} width\n                     * @param {number} height\n                     * @param {number} slope\n                     * @param {object} [options]\n                     * @return {body} A new trapezoid body\n                     */\n                    Bodies.trapezoid = function (x, y, width, height, slope, options) {\n                        options = options || {};\n\n                        slope *= 0.5;\n                        var roof = (1 - slope * 2) * width;\n\n                        var x1 = width * slope,\n                            x2 = x1 + roof,\n                            x3 = x2 + x1,\n                            verticesPath;\n\n                        if (slope < 0.5) {\n                            verticesPath = 'L 0 0 L ' + x1 + ' ' + -height + ' L ' + x2 + ' ' + -height + ' L ' + x3 + ' 0';\n                        } else {\n                            verticesPath = 'L 0 0 L ' + x2 + ' ' + -height + ' L ' + x3 + ' 0';\n                        }\n\n                        var trapezoid = {\n                            label: 'Trapezoid Body',\n                            position: { x: x, y: y },\n                            vertices: Vertices.fromPath(verticesPath)\n                        };\n\n                        if (options.chamfer) {\n                            var chamfer = options.chamfer;\n                            trapezoid.vertices = Vertices.chamfer(trapezoid.vertices, chamfer.radius, chamfer.quality, chamfer.qualityMin, chamfer.qualityMax);\n                            delete options.chamfer;\n                        }\n\n                        return Body.create(Common.extend({}, trapezoid, options));\n                    };\n\n                    /**\n                     * Creates a new rigid body model with a circle hull. \n                     * The options parameter is an object that specifies any properties you wish to override the defaults.\n                     * See the properties section of the `Matter.Body` module for detailed information on what you can pass via the `options` object.\n                     * @method circle\n                     * @param {number} x\n                     * @param {number} y\n                     * @param {number} radius\n                     * @param {object} [options]\n                     * @param {number} [maxSides]\n                     * @return {body} A new circle body\n                     */\n                    Bodies.circle = function (x, y, radius, options, maxSides) {\n                        options = options || {};\n\n                        var circle = {\n                            label: 'Circle Body',\n                            circleRadius: radius\n                        };\n\n                        // approximate circles with polygons until true circles implemented in SAT\n                        maxSides = maxSides || 25;\n                        var sides = Math.ceil(Math.max(10, Math.min(maxSides, radius)));\n\n                        // optimisation: always use even number of sides (half the number of unique axes)\n                        if (sides % 2 === 1) sides += 1;\n\n                        return Bodies.polygon(x, y, sides, radius, Common.extend({}, circle, options));\n                    };\n\n                    /**\n                     * Creates a new rigid body model with a regular polygon hull with the given number of sides. \n                     * The options parameter is an object that specifies any properties you wish to override the defaults.\n                     * See the properties section of the `Matter.Body` module for detailed information on what you can pass via the `options` object.\n                     * @method polygon\n                     * @param {number} x\n                     * @param {number} y\n                     * @param {number} sides\n                     * @param {number} radius\n                     * @param {object} [options]\n                     * @return {body} A new regular polygon body\n                     */\n                    Bodies.polygon = function (x, y, sides, radius, options) {\n                        options = options || {};\n\n                        if (sides < 3) return Bodies.circle(x, y, radius, options);\n\n                        var theta = 2 * Math.PI / sides,\n                            path = '',\n                            offset = theta * 0.5;\n\n                        for (var i = 0; i < sides; i += 1) {\n                            var angle = offset + i * theta,\n                                xx = Math.cos(angle) * radius,\n                                yy = Math.sin(angle) * radius;\n\n                            path += 'L ' + xx.toFixed(3) + ' ' + yy.toFixed(3) + ' ';\n                        }\n\n                        var polygon = {\n                            label: 'Polygon Body',\n                            position: { x: x, y: y },\n                            vertices: Vertices.fromPath(path)\n                        };\n\n                        if (options.chamfer) {\n                            var chamfer = options.chamfer;\n                            polygon.vertices = Vertices.chamfer(polygon.vertices, chamfer.radius, chamfer.quality, chamfer.qualityMin, chamfer.qualityMax);\n                            delete options.chamfer;\n                        }\n\n                        return Body.create(Common.extend({}, polygon, options));\n                    };\n\n                    /**\n                     * Creates a body using the supplied vertices (or an array containing multiple sets of vertices).\n                     * If the vertices are convex, they will pass through as supplied.\n                     * Otherwise if the vertices are concave, they will be decomposed if [poly-decomp.js](https://github.com/schteppe/poly-decomp.js) is available.\n                     * Note that this process is not guaranteed to support complex sets of vertices (e.g. those with holes may fail).\n                     * By default the decomposition will discard collinear edges (to improve performance).\n                     * It can also optionally discard any parts that have an area less than `minimumArea`.\n                     * If the vertices can not be decomposed, the result will fall back to using the convex hull.\n                     * The options parameter is an object that specifies any `Matter.Body` properties you wish to override the defaults.\n                     * See the properties section of the `Matter.Body` module for detailed information on what you can pass via the `options` object.\n                     * @method fromVertices\n                     * @param {number} x\n                     * @param {number} y\n                     * @param [[vector]] vertexSets\n                     * @param {object} [options]\n                     * @param {bool} [flagInternal=false]\n                     * @param {number} [removeCollinear=0.01]\n                     * @param {number} [minimumArea=10]\n                     * @return {body}\n                     */\n                    Bodies.fromVertices = function (x, y, vertexSets, options, flagInternal, removeCollinear, minimumArea) {\n                        var body, parts, isConvex, vertices, i, j, k, v, z;\n\n                        options = options || {};\n                        parts = [];\n\n                        flagInternal = typeof flagInternal !== 'undefined' ? flagInternal : false;\n                        removeCollinear = typeof removeCollinear !== 'undefined' ? removeCollinear : 0.01;\n                        minimumArea = typeof minimumArea !== 'undefined' ? minimumArea : 10;\n\n                        if (!decomp) {\n                            Common.warn('Bodies.fromVertices: poly-decomp.js required. Could not decompose vertices. Fallback to convex hull.');\n                        }\n\n                        // ensure vertexSets is an array of arrays\n                        if (!Common.isArray(vertexSets[0])) {\n                            vertexSets = [vertexSets];\n                        }\n\n                        for (v = 0; v < vertexSets.length; v += 1) {\n                            vertices = vertexSets[v];\n                            isConvex = Vertices.isConvex(vertices);\n\n                            if (isConvex || !decomp) {\n                                if (isConvex) {\n                                    vertices = Vertices.clockwiseSort(vertices);\n                                } else {\n                                    // fallback to convex hull when decomposition is not possible\n                                    vertices = Vertices.hull(vertices);\n                                }\n\n                                parts.push({\n                                    position: { x: x, y: y },\n                                    vertices: vertices\n                                });\n                            } else {\n                                // initialise a decomposition\n                                var concave = vertices.map(function (vertex) {\n                                    return [vertex.x, vertex.y];\n                                });\n\n                                // vertices are concave and simple, we can decompose into parts\n                                decomp.makeCCW(concave);\n                                if (removeCollinear !== false) decomp.removeCollinearPoints(concave, removeCollinear);\n\n                                // use the quick decomposition algorithm (Bayazit)\n                                var decomposed = decomp.quickDecomp(concave);\n\n                                // for each decomposed chunk\n                                for (i = 0; i < decomposed.length; i++) {\n                                    var chunk = decomposed[i];\n\n                                    // convert vertices into the correct structure\n                                    var chunkVertices = chunk.map(function (vertices) {\n                                        return {\n                                            x: vertices[0],\n                                            y: vertices[1]\n                                        };\n                                    });\n\n                                    // skip small chunks\n                                    if (minimumArea > 0 && Vertices.area(chunkVertices) < minimumArea) continue;\n\n                                    // create a compound part\n                                    parts.push({\n                                        position: Vertices.centre(chunkVertices),\n                                        vertices: chunkVertices\n                                    });\n                                }\n                            }\n                        }\n\n                        // create body parts\n                        for (i = 0; i < parts.length; i++) {\n                            parts[i] = Body.create(Common.extend(parts[i], options));\n                        }\n\n                        // flag internal edges (coincident part edges)\n                        if (flagInternal) {\n                            var coincident_max_dist = 5;\n\n                            for (i = 0; i < parts.length; i++) {\n                                var partA = parts[i];\n\n                                for (j = i + 1; j < parts.length; j++) {\n                                    var partB = parts[j];\n\n                                    if (Bounds.overlaps(partA.bounds, partB.bounds)) {\n                                        var pav = partA.vertices,\n                                            pbv = partB.vertices;\n\n                                        // iterate vertices of both parts\n                                        for (k = 0; k < partA.vertices.length; k++) {\n                                            for (z = 0; z < partB.vertices.length; z++) {\n                                                // find distances between the vertices\n                                                var da = Vector.magnitudeSquared(Vector.sub(pav[(k + 1) % pav.length], pbv[z])),\n                                                    db = Vector.magnitudeSquared(Vector.sub(pav[k], pbv[(z + 1) % pbv.length]));\n\n                                                // if both vertices are very close, consider the edge concident (internal)\n                                                if (da < coincident_max_dist && db < coincident_max_dist) {\n                                                    pav[k].isInternal = true;\n                                                    pbv[z].isInternal = true;\n                                                }\n                                            }\n                                        }\n                                    }\n                                }\n                            }\n                        }\n\n                        if (parts.length > 1) {\n                            // create the parent body to be returned, that contains generated compound parts\n                            body = Body.create(Common.extend({ parts: parts.slice(0) }, options));\n                            Body.setPosition(body, { x: x, y: y });\n\n                            return body;\n                        } else {\n                            return parts[0];\n                        }\n                    };\n                })();\n            }).call(this, typeof global !== \"undefined\" ? global : typeof self !== \"undefined\" ? self : typeof window !== \"undefined\" ? window : {});\n        }, { \"../body/Body\": 1, \"../core/Common\": 14, \"../geometry/Bounds\": 26, \"../geometry/Vector\": 28, \"../geometry/Vertices\": 29 }], 24: [function (_dereq_, module, exports) {\n            /**\n            * The `Matter.Composites` module contains factory methods for creating composite bodies\n            * with commonly used configurations (such as stacks and chains).\n            *\n            * See the included usage [examples](https://github.com/liabru/matter-js/tree/master/examples).\n            *\n            * @class Composites\n            */\n\n            var Composites = {};\n\n            module.exports = Composites;\n\n            var Composite = _dereq_('../body/Composite');\n            var Constraint = _dereq_('../constraint/Constraint');\n            var Common = _dereq_('../core/Common');\n            var Body = _dereq_('../body/Body');\n            var Bodies = _dereq_('./Bodies');\n\n            (function () {\n\n                /**\n                 * Create a new composite containing bodies created in the callback in a grid arrangement.\n                 * This function uses the body's bounds to prevent overlaps.\n                 * @method stack\n                 * @param {number} xx\n                 * @param {number} yy\n                 * @param {number} columns\n                 * @param {number} rows\n                 * @param {number} columnGap\n                 * @param {number} rowGap\n                 * @param {function} callback\n                 * @return {composite} A new composite containing objects created in the callback\n                 */\n                Composites.stack = function (xx, yy, columns, rows, columnGap, rowGap, callback) {\n                    var stack = Composite.create({ label: 'Stack' }),\n                        x = xx,\n                        y = yy,\n                        lastBody,\n                        i = 0;\n\n                    for (var row = 0; row < rows; row++) {\n                        var maxHeight = 0;\n\n                        for (var column = 0; column < columns; column++) {\n                            var body = callback(x, y, column, row, lastBody, i);\n\n                            if (body) {\n                                var bodyHeight = body.bounds.max.y - body.bounds.min.y,\n                                    bodyWidth = body.bounds.max.x - body.bounds.min.x;\n\n                                if (bodyHeight > maxHeight) maxHeight = bodyHeight;\n\n                                Body.translate(body, { x: bodyWidth * 0.5, y: bodyHeight * 0.5 });\n\n                                x = body.bounds.max.x + columnGap;\n\n                                Composite.addBody(stack, body);\n\n                                lastBody = body;\n                                i += 1;\n                            } else {\n                                x += columnGap;\n                            }\n                        }\n\n                        y += maxHeight + rowGap;\n                        x = xx;\n                    }\n\n                    return stack;\n                };\n\n                /**\n                 * Chains all bodies in the given composite together using constraints.\n                 * @method chain\n                 * @param {composite} composite\n                 * @param {number} xOffsetA\n                 * @param {number} yOffsetA\n                 * @param {number} xOffsetB\n                 * @param {number} yOffsetB\n                 * @param {object} options\n                 * @return {composite} A new composite containing objects chained together with constraints\n                 */\n                Composites.chain = function (composite, xOffsetA, yOffsetA, xOffsetB, yOffsetB, options) {\n                    var bodies = composite.bodies;\n\n                    for (var i = 1; i < bodies.length; i++) {\n                        var bodyA = bodies[i - 1],\n                            bodyB = bodies[i],\n                            bodyAHeight = bodyA.bounds.max.y - bodyA.bounds.min.y,\n                            bodyAWidth = bodyA.bounds.max.x - bodyA.bounds.min.x,\n                            bodyBHeight = bodyB.bounds.max.y - bodyB.bounds.min.y,\n                            bodyBWidth = bodyB.bounds.max.x - bodyB.bounds.min.x;\n\n                        var defaults = {\n                            bodyA: bodyA,\n                            pointA: { x: bodyAWidth * xOffsetA, y: bodyAHeight * yOffsetA },\n                            bodyB: bodyB,\n                            pointB: { x: bodyBWidth * xOffsetB, y: bodyBHeight * yOffsetB }\n                        };\n\n                        var constraint = Common.extend(defaults, options);\n\n                        Composite.addConstraint(composite, Constraint.create(constraint));\n                    }\n\n                    composite.label += ' Chain';\n\n                    return composite;\n                };\n\n                /**\n                 * Connects bodies in the composite with constraints in a grid pattern, with optional cross braces.\n                 * @method mesh\n                 * @param {composite} composite\n                 * @param {number} columns\n                 * @param {number} rows\n                 * @param {boolean} crossBrace\n                 * @param {object} options\n                 * @return {composite} The composite containing objects meshed together with constraints\n                 */\n                Composites.mesh = function (composite, columns, rows, crossBrace, options) {\n                    var bodies = composite.bodies,\n                        row,\n                        col,\n                        bodyA,\n                        bodyB,\n                        bodyC;\n\n                    for (row = 0; row < rows; row++) {\n                        for (col = 1; col < columns; col++) {\n                            bodyA = bodies[col - 1 + row * columns];\n                            bodyB = bodies[col + row * columns];\n                            Composite.addConstraint(composite, Constraint.create(Common.extend({ bodyA: bodyA, bodyB: bodyB }, options)));\n                        }\n\n                        if (row > 0) {\n                            for (col = 0; col < columns; col++) {\n                                bodyA = bodies[col + (row - 1) * columns];\n                                bodyB = bodies[col + row * columns];\n                                Composite.addConstraint(composite, Constraint.create(Common.extend({ bodyA: bodyA, bodyB: bodyB }, options)));\n\n                                if (crossBrace && col > 0) {\n                                    bodyC = bodies[col - 1 + (row - 1) * columns];\n                                    Composite.addConstraint(composite, Constraint.create(Common.extend({ bodyA: bodyC, bodyB: bodyB }, options)));\n                                }\n\n                                if (crossBrace && col < columns - 1) {\n                                    bodyC = bodies[col + 1 + (row - 1) * columns];\n                                    Composite.addConstraint(composite, Constraint.create(Common.extend({ bodyA: bodyC, bodyB: bodyB }, options)));\n                                }\n                            }\n                        }\n                    }\n\n                    composite.label += ' Mesh';\n\n                    return composite;\n                };\n\n                /**\n                 * Create a new composite containing bodies created in the callback in a pyramid arrangement.\n                 * This function uses the body's bounds to prevent overlaps.\n                 * @method pyramid\n                 * @param {number} xx\n                 * @param {number} yy\n                 * @param {number} columns\n                 * @param {number} rows\n                 * @param {number} columnGap\n                 * @param {number} rowGap\n                 * @param {function} callback\n                 * @return {composite} A new composite containing objects created in the callback\n                 */\n                Composites.pyramid = function (xx, yy, columns, rows, columnGap, rowGap, callback) {\n                    return Composites.stack(xx, yy, columns, rows, columnGap, rowGap, function (x, y, column, row, lastBody, i) {\n                        var actualRows = Math.min(rows, Math.ceil(columns / 2)),\n                            lastBodyWidth = lastBody ? lastBody.bounds.max.x - lastBody.bounds.min.x : 0;\n\n                        if (row > actualRows) return;\n\n                        // reverse row order\n                        row = actualRows - row;\n\n                        var start = row,\n                            end = columns - 1 - row;\n\n                        if (column < start || column > end) return;\n\n                        // retroactively fix the first body's position, since width was unknown\n                        if (i === 1) {\n                            Body.translate(lastBody, { x: (column + (columns % 2 === 1 ? 1 : -1)) * lastBodyWidth, y: 0 });\n                        }\n\n                        var xOffset = lastBody ? column * lastBodyWidth : 0;\n\n                        return callback(xx + xOffset + column * columnGap, y, column, row, lastBody, i);\n                    });\n                };\n\n                /**\n                 * Creates a composite with a Newton's Cradle setup of bodies and constraints.\n                 * @method newtonsCradle\n                 * @param {number} xx\n                 * @param {number} yy\n                 * @param {number} number\n                 * @param {number} size\n                 * @param {number} length\n                 * @return {composite} A new composite newtonsCradle body\n                 */\n                Composites.newtonsCradle = function (xx, yy, number, size, length) {\n                    var newtonsCradle = Composite.create({ label: 'Newtons Cradle' });\n\n                    for (var i = 0; i < number; i++) {\n                        var separation = 1.9,\n                            circle = Bodies.circle(xx + i * (size * separation), yy + length, size, { inertia: Infinity, restitution: 1, friction: 0, frictionAir: 0.0001, slop: 1 }),\n                            constraint = Constraint.create({ pointA: { x: xx + i * (size * separation), y: yy }, bodyB: circle });\n\n                        Composite.addBody(newtonsCradle, circle);\n                        Composite.addConstraint(newtonsCradle, constraint);\n                    }\n\n                    return newtonsCradle;\n                };\n\n                /**\n                 * Creates a composite with simple car setup of bodies and constraints.\n                 * @method car\n                 * @param {number} xx\n                 * @param {number} yy\n                 * @param {number} width\n                 * @param {number} height\n                 * @param {number} wheelSize\n                 * @return {composite} A new composite car body\n                 */\n                Composites.car = function (xx, yy, width, height, wheelSize) {\n                    var group = Body.nextGroup(true),\n                        wheelBase = 20,\n                        wheelAOffset = -width * 0.5 + wheelBase,\n                        wheelBOffset = width * 0.5 - wheelBase,\n                        wheelYOffset = 0;\n\n                    var car = Composite.create({ label: 'Car' }),\n                        body = Bodies.rectangle(xx, yy, width, height, {\n                        collisionFilter: {\n                            group: group\n                        },\n                        chamfer: {\n                            radius: height * 0.5\n                        },\n                        density: 0.0002\n                    });\n\n                    var wheelA = Bodies.circle(xx + wheelAOffset, yy + wheelYOffset, wheelSize, {\n                        collisionFilter: {\n                            group: group\n                        },\n                        friction: 0.8\n                    });\n\n                    var wheelB = Bodies.circle(xx + wheelBOffset, yy + wheelYOffset, wheelSize, {\n                        collisionFilter: {\n                            group: group\n                        },\n                        friction: 0.8\n                    });\n\n                    var axelA = Constraint.create({\n                        bodyB: body,\n                        pointB: { x: wheelAOffset, y: wheelYOffset },\n                        bodyA: wheelA,\n                        stiffness: 1,\n                        length: 0\n                    });\n\n                    var axelB = Constraint.create({\n                        bodyB: body,\n                        pointB: { x: wheelBOffset, y: wheelYOffset },\n                        bodyA: wheelB,\n                        stiffness: 1,\n                        length: 0\n                    });\n\n                    Composite.addBody(car, body);\n                    Composite.addBody(car, wheelA);\n                    Composite.addBody(car, wheelB);\n                    Composite.addConstraint(car, axelA);\n                    Composite.addConstraint(car, axelB);\n\n                    return car;\n                };\n\n                /**\n                 * Creates a simple soft body like object.\n                 * @method softBody\n                 * @param {number} xx\n                 * @param {number} yy\n                 * @param {number} columns\n                 * @param {number} rows\n                 * @param {number} columnGap\n                 * @param {number} rowGap\n                 * @param {boolean} crossBrace\n                 * @param {number} particleRadius\n                 * @param {} particleOptions\n                 * @param {} constraintOptions\n                 * @return {composite} A new composite softBody\n                 */\n                Composites.softBody = function (xx, yy, columns, rows, columnGap, rowGap, crossBrace, particleRadius, particleOptions, constraintOptions) {\n                    particleOptions = Common.extend({ inertia: Infinity }, particleOptions);\n                    constraintOptions = Common.extend({ stiffness: 0.2, render: { type: 'line', anchors: false } }, constraintOptions);\n\n                    var softBody = Composites.stack(xx, yy, columns, rows, columnGap, rowGap, function (x, y) {\n                        return Bodies.circle(x, y, particleRadius, particleOptions);\n                    });\n\n                    Composites.mesh(softBody, columns, rows, crossBrace, constraintOptions);\n\n                    softBody.label = 'Soft Body';\n\n                    return softBody;\n                };\n            })();\n        }, { \"../body/Body\": 1, \"../body/Composite\": 2, \"../constraint/Constraint\": 12, \"../core/Common\": 14, \"./Bodies\": 23 }], 25: [function (_dereq_, module, exports) {\n            /**\n            * The `Matter.Axes` module contains methods for creating and manipulating sets of axes.\n            *\n            * @class Axes\n            */\n\n            var Axes = {};\n\n            module.exports = Axes;\n\n            var Vector = _dereq_('../geometry/Vector');\n            var Common = _dereq_('../core/Common');\n\n            (function () {\n\n                /**\n                 * Creates a new set of axes from the given vertices.\n                 * @method fromVertices\n                 * @param {vertices} vertices\n                 * @return {axes} A new axes from the given vertices\n                 */\n                Axes.fromVertices = function (vertices) {\n                    var axes = {};\n\n                    // find the unique axes, using edge normal gradients\n                    for (var i = 0; i < vertices.length; i++) {\n                        var j = (i + 1) % vertices.length,\n                            normal = Vector.normalise({\n                            x: vertices[j].y - vertices[i].y,\n                            y: vertices[i].x - vertices[j].x\n                        }),\n                            gradient = normal.y === 0 ? Infinity : normal.x / normal.y;\n\n                        // limit precision\n                        gradient = gradient.toFixed(3).toString();\n                        axes[gradient] = normal;\n                    }\n\n                    return Common.values(axes);\n                };\n\n                /**\n                 * Rotates a set of axes by the given angle.\n                 * @method rotate\n                 * @param {axes} axes\n                 * @param {number} angle\n                 */\n                Axes.rotate = function (axes, angle) {\n                    if (angle === 0) return;\n\n                    var cos = Math.cos(angle),\n                        sin = Math.sin(angle);\n\n                    for (var i = 0; i < axes.length; i++) {\n                        var axis = axes[i],\n                            xx;\n                        xx = axis.x * cos - axis.y * sin;\n                        axis.y = axis.x * sin + axis.y * cos;\n                        axis.x = xx;\n                    }\n                };\n            })();\n        }, { \"../core/Common\": 14, \"../geometry/Vector\": 28 }], 26: [function (_dereq_, module, exports) {\n            /**\n            * The `Matter.Bounds` module contains methods for creating and manipulating axis-aligned bounding boxes (AABB).\n            *\n            * @class Bounds\n            */\n\n            var Bounds = {};\n\n            module.exports = Bounds;\n\n            (function () {\n\n                /**\n                 * Creates a new axis-aligned bounding box (AABB) for the given vertices.\n                 * @method create\n                 * @param {vertices} vertices\n                 * @return {bounds} A new bounds object\n                 */\n                Bounds.create = function (vertices) {\n                    var bounds = {\n                        min: { x: 0, y: 0 },\n                        max: { x: 0, y: 0 }\n                    };\n\n                    if (vertices) Bounds.update(bounds, vertices);\n\n                    return bounds;\n                };\n\n                /**\n                 * Updates bounds using the given vertices and extends the bounds given a velocity.\n                 * @method update\n                 * @param {bounds} bounds\n                 * @param {vertices} vertices\n                 * @param {vector} velocity\n                 */\n                Bounds.update = function (bounds, vertices, velocity) {\n                    bounds.min.x = Infinity;\n                    bounds.max.x = -Infinity;\n                    bounds.min.y = Infinity;\n                    bounds.max.y = -Infinity;\n\n                    for (var i = 0; i < vertices.length; i++) {\n                        var vertex = vertices[i];\n                        if (vertex.x > bounds.max.x) bounds.max.x = vertex.x;\n                        if (vertex.x < bounds.min.x) bounds.min.x = vertex.x;\n                        if (vertex.y > bounds.max.y) bounds.max.y = vertex.y;\n                        if (vertex.y < bounds.min.y) bounds.min.y = vertex.y;\n                    }\n\n                    if (velocity) {\n                        if (velocity.x > 0) {\n                            bounds.max.x += velocity.x;\n                        } else {\n                            bounds.min.x += velocity.x;\n                        }\n\n                        if (velocity.y > 0) {\n                            bounds.max.y += velocity.y;\n                        } else {\n                            bounds.min.y += velocity.y;\n                        }\n                    }\n                };\n\n                /**\n                 * Returns true if the bounds contains the given point.\n                 * @method contains\n                 * @param {bounds} bounds\n                 * @param {vector} point\n                 * @return {boolean} True if the bounds contain the point, otherwise false\n                 */\n                Bounds.contains = function (bounds, point) {\n                    return point.x >= bounds.min.x && point.x <= bounds.max.x && point.y >= bounds.min.y && point.y <= bounds.max.y;\n                };\n\n                /**\n                 * Returns true if the two bounds intersect.\n                 * @method overlaps\n                 * @param {bounds} boundsA\n                 * @param {bounds} boundsB\n                 * @return {boolean} True if the bounds overlap, otherwise false\n                 */\n                Bounds.overlaps = function (boundsA, boundsB) {\n                    return boundsA.min.x <= boundsB.max.x && boundsA.max.x >= boundsB.min.x && boundsA.max.y >= boundsB.min.y && boundsA.min.y <= boundsB.max.y;\n                };\n\n                /**\n                 * Translates the bounds by the given vector.\n                 * @method translate\n                 * @param {bounds} bounds\n                 * @param {vector} vector\n                 */\n                Bounds.translate = function (bounds, vector) {\n                    bounds.min.x += vector.x;\n                    bounds.max.x += vector.x;\n                    bounds.min.y += vector.y;\n                    bounds.max.y += vector.y;\n                };\n\n                /**\n                 * Shifts the bounds to the given position.\n                 * @method shift\n                 * @param {bounds} bounds\n                 * @param {vector} position\n                 */\n                Bounds.shift = function (bounds, position) {\n                    var deltaX = bounds.max.x - bounds.min.x,\n                        deltaY = bounds.max.y - bounds.min.y;\n\n                    bounds.min.x = position.x;\n                    bounds.max.x = position.x + deltaX;\n                    bounds.min.y = position.y;\n                    bounds.max.y = position.y + deltaY;\n                };\n            })();\n        }, {}], 27: [function (_dereq_, module, exports) {\n            /**\n            * The `Matter.Svg` module contains methods for converting SVG images into an array of vector points.\n            *\n            * To use this module you also need the SVGPathSeg polyfill: https://github.com/progers/pathseg\n            *\n            * See the included usage [examples](https://github.com/liabru/matter-js/tree/master/examples).\n            *\n            * @class Svg\n            */\n\n            var Svg = {};\n\n            module.exports = Svg;\n\n            var Bounds = _dereq_('../geometry/Bounds');\n\n            (function () {\n\n                /**\n                 * Converts an SVG path into an array of vector points.\n                 * If the input path forms a concave shape, you must decompose the result into convex parts before use.\n                 * See `Bodies.fromVertices` which provides support for this.\n                 * Note that this function is not guaranteed to support complex paths (such as those with holes).\n                 * @method pathToVertices\n                 * @param {SVGPathElement} path\n                 * @param {Number} [sampleLength=15]\n                 * @return {Vector[]} points\n                 */\n                Svg.pathToVertices = function (path, sampleLength) {\n                    // https://github.com/wout/svg.topoly.js/blob/master/svg.topoly.js\n                    var i,\n                        il,\n                        total,\n                        point,\n                        segment,\n                        segments,\n                        segmentsQueue,\n                        lastSegment,\n                        lastPoint,\n                        segmentIndex,\n                        points = [],\n                        lx,\n                        ly,\n                        length = 0,\n                        x = 0,\n                        y = 0;\n\n                    sampleLength = sampleLength || 15;\n\n                    var addPoint = function addPoint(px, py, pathSegType) {\n                        // all odd-numbered path types are relative except PATHSEG_CLOSEPATH (1)\n                        var isRelative = pathSegType % 2 === 1 && pathSegType > 1;\n\n                        // when the last point doesn't equal the current point add the current point\n                        if (!lastPoint || px != lastPoint.x || py != lastPoint.y) {\n                            if (lastPoint && isRelative) {\n                                lx = lastPoint.x;\n                                ly = lastPoint.y;\n                            } else {\n                                lx = 0;\n                                ly = 0;\n                            }\n\n                            var point = {\n                                x: lx + px,\n                                y: ly + py\n                            };\n\n                            // set last point\n                            if (isRelative || !lastPoint) {\n                                lastPoint = point;\n                            }\n\n                            points.push(point);\n\n                            x = lx + px;\n                            y = ly + py;\n                        }\n                    };\n\n                    var addSegmentPoint = function addSegmentPoint(segment) {\n                        var segType = segment.pathSegTypeAsLetter.toUpperCase();\n\n                        // skip path ends\n                        if (segType === 'Z') return;\n\n                        // map segment to x and y\n                        switch (segType) {\n\n                            case 'M':\n                            case 'L':\n                            case 'T':\n                            case 'C':\n                            case 'S':\n                            case 'Q':\n                                x = segment.x;\n                                y = segment.y;\n                                break;\n                            case 'H':\n                                x = segment.x;\n                                break;\n                            case 'V':\n                                y = segment.y;\n                                break;\n                        }\n\n                        addPoint(x, y, segment.pathSegType);\n                    };\n\n                    // ensure path is absolute\n                    Svg._svgPathToAbsolute(path);\n\n                    // get total length\n                    total = path.getTotalLength();\n\n                    // queue segments\n                    segments = [];\n                    for (i = 0; i < path.pathSegList.numberOfItems; i += 1) {\n                        segments.push(path.pathSegList.getItem(i));\n                    }segmentsQueue = segments.concat();\n\n                    // sample through path\n                    while (length < total) {\n                        // get segment at position\n                        segmentIndex = path.getPathSegAtLength(length);\n                        segment = segments[segmentIndex];\n\n                        // new segment\n                        if (segment != lastSegment) {\n                            while (segmentsQueue.length && segmentsQueue[0] != segment) {\n                                addSegmentPoint(segmentsQueue.shift());\n                            }lastSegment = segment;\n                        }\n\n                        // add points in between when curving\n                        // TODO: adaptive sampling\n                        switch (segment.pathSegTypeAsLetter.toUpperCase()) {\n\n                            case 'C':\n                            case 'T':\n                            case 'S':\n                            case 'Q':\n                            case 'A':\n                                point = path.getPointAtLength(length);\n                                addPoint(point.x, point.y, 0);\n                                break;\n\n                        }\n\n                        // increment by sample value\n                        length += sampleLength;\n                    }\n\n                    // add remaining segments not passed by sampling\n                    for (i = 0, il = segmentsQueue.length; i < il; ++i) {\n                        addSegmentPoint(segmentsQueue[i]);\n                    }return points;\n                };\n\n                Svg._svgPathToAbsolute = function (path) {\n                    // http://phrogz.net/convert-svg-path-to-all-absolute-commands\n                    // Copyright (c) Gavin Kistner\n                    // http://phrogz.net/js/_ReuseLicense.txt\n                    // Modifications: tidy formatting and naming\n                    var x0,\n                        y0,\n                        x1,\n                        y1,\n                        x2,\n                        y2,\n                        segs = path.pathSegList,\n                        x = 0,\n                        y = 0,\n                        len = segs.numberOfItems;\n\n                    for (var i = 0; i < len; ++i) {\n                        var seg = segs.getItem(i),\n                            segType = seg.pathSegTypeAsLetter;\n\n                        if (/[MLHVCSQTA]/.test(segType)) {\n                            if ('x' in seg) x = seg.x;\n                            if ('y' in seg) y = seg.y;\n                        } else {\n                            if ('x1' in seg) x1 = x + seg.x1;\n                            if ('x2' in seg) x2 = x + seg.x2;\n                            if ('y1' in seg) y1 = y + seg.y1;\n                            if ('y2' in seg) y2 = y + seg.y2;\n                            if ('x' in seg) x += seg.x;\n                            if ('y' in seg) y += seg.y;\n\n                            switch (segType) {\n\n                                case 'm':\n                                    segs.replaceItem(path.createSVGPathSegMovetoAbs(x, y), i);\n                                    break;\n                                case 'l':\n                                    segs.replaceItem(path.createSVGPathSegLinetoAbs(x, y), i);\n                                    break;\n                                case 'h':\n                                    segs.replaceItem(path.createSVGPathSegLinetoHorizontalAbs(x), i);\n                                    break;\n                                case 'v':\n                                    segs.replaceItem(path.createSVGPathSegLinetoVerticalAbs(y), i);\n                                    break;\n                                case 'c':\n                                    segs.replaceItem(path.createSVGPathSegCurvetoCubicAbs(x, y, x1, y1, x2, y2), i);\n                                    break;\n                                case 's':\n                                    segs.replaceItem(path.createSVGPathSegCurvetoCubicSmoothAbs(x, y, x2, y2), i);\n                                    break;\n                                case 'q':\n                                    segs.replaceItem(path.createSVGPathSegCurvetoQuadraticAbs(x, y, x1, y1), i);\n                                    break;\n                                case 't':\n                                    segs.replaceItem(path.createSVGPathSegCurvetoQuadraticSmoothAbs(x, y), i);\n                                    break;\n                                case 'a':\n                                    segs.replaceItem(path.createSVGPathSegArcAbs(x, y, seg.r1, seg.r2, seg.angle, seg.largeArcFlag, seg.sweepFlag), i);\n                                    break;\n                                case 'z':\n                                case 'Z':\n                                    x = x0;\n                                    y = y0;\n                                    break;\n\n                            }\n                        }\n\n                        if (segType == 'M' || segType == 'm') {\n                            x0 = x;\n                            y0 = y;\n                        }\n                    }\n                };\n            })();\n        }, { \"../geometry/Bounds\": 26 }], 28: [function (_dereq_, module, exports) {\n            /**\n            * The `Matter.Vector` module contains methods for creating and manipulating vectors.\n            * Vectors are the basis of all the geometry related operations in the engine.\n            * A `Matter.Vector` object is of the form `{ x: 0, y: 0 }`.\n            *\n            * See the included usage [examples](https://github.com/liabru/matter-js/tree/master/examples).\n            *\n            * @class Vector\n            */\n\n            // TODO: consider params for reusing vector objects\n\n            var Vector = {};\n\n            module.exports = Vector;\n\n            (function () {\n\n                /**\n                 * Creates a new vector.\n                 * @method create\n                 * @param {number} x\n                 * @param {number} y\n                 * @return {vector} A new vector\n                 */\n                Vector.create = function (x, y) {\n                    return { x: x || 0, y: y || 0 };\n                };\n\n                /**\n                 * Returns a new vector with `x` and `y` copied from the given `vector`.\n                 * @method clone\n                 * @param {vector} vector\n                 * @return {vector} A new cloned vector\n                 */\n                Vector.clone = function (vector) {\n                    return { x: vector.x, y: vector.y };\n                };\n\n                /**\n                 * Returns the magnitude (length) of a vector.\n                 * @method magnitude\n                 * @param {vector} vector\n                 * @return {number} The magnitude of the vector\n                 */\n                Vector.magnitude = function (vector) {\n                    return Math.sqrt(vector.x * vector.x + vector.y * vector.y);\n                };\n\n                /**\n                 * Returns the magnitude (length) of a vector (therefore saving a `sqrt` operation).\n                 * @method magnitudeSquared\n                 * @param {vector} vector\n                 * @return {number} The squared magnitude of the vector\n                 */\n                Vector.magnitudeSquared = function (vector) {\n                    return vector.x * vector.x + vector.y * vector.y;\n                };\n\n                /**\n                 * Rotates the vector about (0, 0) by specified angle.\n                 * @method rotate\n                 * @param {vector} vector\n                 * @param {number} angle\n                 * @param {vector} [output]\n                 * @return {vector} The vector rotated about (0, 0)\n                 */\n                Vector.rotate = function (vector, angle, output) {\n                    var cos = Math.cos(angle),\n                        sin = Math.sin(angle);\n                    if (!output) output = {};\n                    var x = vector.x * cos - vector.y * sin;\n                    output.y = vector.x * sin + vector.y * cos;\n                    output.x = x;\n                    return output;\n                };\n\n                /**\n                 * Rotates the vector about a specified point by specified angle.\n                 * @method rotateAbout\n                 * @param {vector} vector\n                 * @param {number} angle\n                 * @param {vector} point\n                 * @param {vector} [output]\n                 * @return {vector} A new vector rotated about the point\n                 */\n                Vector.rotateAbout = function (vector, angle, point, output) {\n                    var cos = Math.cos(angle),\n                        sin = Math.sin(angle);\n                    if (!output) output = {};\n                    var x = point.x + ((vector.x - point.x) * cos - (vector.y - point.y) * sin);\n                    output.y = point.y + ((vector.x - point.x) * sin + (vector.y - point.y) * cos);\n                    output.x = x;\n                    return output;\n                };\n\n                /**\n                 * Normalises a vector (such that its magnitude is `1`).\n                 * @method normalise\n                 * @param {vector} vector\n                 * @return {vector} A new vector normalised\n                 */\n                Vector.normalise = function (vector) {\n                    var magnitude = Vector.magnitude(vector);\n                    if (magnitude === 0) return { x: 0, y: 0 };\n                    return { x: vector.x / magnitude, y: vector.y / magnitude };\n                };\n\n                /**\n                 * Returns the dot-product of two vectors.\n                 * @method dot\n                 * @param {vector} vectorA\n                 * @param {vector} vectorB\n                 * @return {number} The dot product of the two vectors\n                 */\n                Vector.dot = function (vectorA, vectorB) {\n                    return vectorA.x * vectorB.x + vectorA.y * vectorB.y;\n                };\n\n                /**\n                 * Returns the cross-product of two vectors.\n                 * @method cross\n                 * @param {vector} vectorA\n                 * @param {vector} vectorB\n                 * @return {number} The cross product of the two vectors\n                 */\n                Vector.cross = function (vectorA, vectorB) {\n                    return vectorA.x * vectorB.y - vectorA.y * vectorB.x;\n                };\n\n                /**\n                 * Returns the cross-product of three vectors.\n                 * @method cross3\n                 * @param {vector} vectorA\n                 * @param {vector} vectorB\n                 * @param {vector} vectorC\n                 * @return {number} The cross product of the three vectors\n                 */\n                Vector.cross3 = function (vectorA, vectorB, vectorC) {\n                    return (vectorB.x - vectorA.x) * (vectorC.y - vectorA.y) - (vectorB.y - vectorA.y) * (vectorC.x - vectorA.x);\n                };\n\n                /**\n                 * Adds the two vectors.\n                 * @method add\n                 * @param {vector} vectorA\n                 * @param {vector} vectorB\n                 * @param {vector} [output]\n                 * @return {vector} A new vector of vectorA and vectorB added\n                 */\n                Vector.add = function (vectorA, vectorB, output) {\n                    if (!output) output = {};\n                    output.x = vectorA.x + vectorB.x;\n                    output.y = vectorA.y + vectorB.y;\n                    return output;\n                };\n\n                /**\n                 * Subtracts the two vectors.\n                 * @method sub\n                 * @param {vector} vectorA\n                 * @param {vector} vectorB\n                 * @param {vector} [output]\n                 * @return {vector} A new vector of vectorA and vectorB subtracted\n                 */\n                Vector.sub = function (vectorA, vectorB, output) {\n                    if (!output) output = {};\n                    output.x = vectorA.x - vectorB.x;\n                    output.y = vectorA.y - vectorB.y;\n                    return output;\n                };\n\n                /**\n                 * Multiplies a vector and a scalar.\n                 * @method mult\n                 * @param {vector} vector\n                 * @param {number} scalar\n                 * @return {vector} A new vector multiplied by scalar\n                 */\n                Vector.mult = function (vector, scalar) {\n                    return { x: vector.x * scalar, y: vector.y * scalar };\n                };\n\n                /**\n                 * Divides a vector and a scalar.\n                 * @method div\n                 * @param {vector} vector\n                 * @param {number} scalar\n                 * @return {vector} A new vector divided by scalar\n                 */\n                Vector.div = function (vector, scalar) {\n                    return { x: vector.x / scalar, y: vector.y / scalar };\n                };\n\n                /**\n                 * Returns the perpendicular vector. Set `negate` to true for the perpendicular in the opposite direction.\n                 * @method perp\n                 * @param {vector} vector\n                 * @param {bool} [negate=false]\n                 * @return {vector} The perpendicular vector\n                 */\n                Vector.perp = function (vector, negate) {\n                    negate = negate === true ? -1 : 1;\n                    return { x: negate * -vector.y, y: negate * vector.x };\n                };\n\n                /**\n                 * Negates both components of a vector such that it points in the opposite direction.\n                 * @method neg\n                 * @param {vector} vector\n                 * @return {vector} The negated vector\n                 */\n                Vector.neg = function (vector) {\n                    return { x: -vector.x, y: -vector.y };\n                };\n\n                /**\n                 * Returns the angle in radians between the two vectors relative to the x-axis.\n                 * @method angle\n                 * @param {vector} vectorA\n                 * @param {vector} vectorB\n                 * @return {number} The angle in radians\n                 */\n                Vector.angle = function (vectorA, vectorB) {\n                    return Math.atan2(vectorB.y - vectorA.y, vectorB.x - vectorA.x);\n                };\n\n                /**\n                 * Temporary vector pool (not thread-safe).\n                 * @property _temp\n                 * @type {vector[]}\n                 * @private\n                 */\n                Vector._temp = [Vector.create(), Vector.create(), Vector.create(), Vector.create(), Vector.create(), Vector.create()];\n            })();\n        }, {}], 29: [function (_dereq_, module, exports) {\n            /**\n            * The `Matter.Vertices` module contains methods for creating and manipulating sets of vertices.\n            * A set of vertices is an array of `Matter.Vector` with additional indexing properties inserted by `Vertices.create`.\n            * A `Matter.Body` maintains a set of vertices to represent the shape of the object (its convex hull).\n            *\n            * See the included usage [examples](https://github.com/liabru/matter-js/tree/master/examples).\n            *\n            * @class Vertices\n            */\n\n            var Vertices = {};\n\n            module.exports = Vertices;\n\n            var Vector = _dereq_('../geometry/Vector');\n            var Common = _dereq_('../core/Common');\n\n            (function () {\n\n                /**\n                 * Creates a new set of `Matter.Body` compatible vertices.\n                 * The `points` argument accepts an array of `Matter.Vector` points orientated around the origin `(0, 0)`, for example:\n                 *\n                 *     [{ x: 0, y: 0 }, { x: 25, y: 50 }, { x: 50, y: 0 }]\n                 *\n                 * The `Vertices.create` method returns a new array of vertices, which are similar to Matter.Vector objects,\n                 * but with some additional references required for efficient collision detection routines.\n                 *\n                 * Vertices must be specified in clockwise order.\n                 *\n                 * Note that the `body` argument is not optional, a `Matter.Body` reference must be provided.\n                 *\n                 * @method create\n                 * @param {vector[]} points\n                 * @param {body} body\n                 */\n                Vertices.create = function (points, body) {\n                    var vertices = [];\n\n                    for (var i = 0; i < points.length; i++) {\n                        var point = points[i],\n                            vertex = {\n                            x: point.x,\n                            y: point.y,\n                            index: i,\n                            body: body,\n                            isInternal: false\n                        };\n\n                        vertices.push(vertex);\n                    }\n\n                    return vertices;\n                };\n\n                /**\n                 * Parses a string containing ordered x y pairs separated by spaces (and optionally commas), \n                 * into a `Matter.Vertices` object for the given `Matter.Body`.\n                 * For parsing SVG paths, see `Svg.pathToVertices`.\n                 * @method fromPath\n                 * @param {string} path\n                 * @param {body} body\n                 * @return {vertices} vertices\n                 */\n                Vertices.fromPath = function (path, body) {\n                    var pathPattern = /L?\\s*([\\-\\d\\.e]+)[\\s,]*([\\-\\d\\.e]+)*/ig,\n                        points = [];\n\n                    path.replace(pathPattern, function (match, x, y) {\n                        points.push({ x: parseFloat(x), y: parseFloat(y) });\n                    });\n\n                    return Vertices.create(points, body);\n                };\n\n                /**\n                 * Returns the centre (centroid) of the set of vertices.\n                 * @method centre\n                 * @param {vertices} vertices\n                 * @return {vector} The centre point\n                 */\n                Vertices.centre = function (vertices) {\n                    var area = Vertices.area(vertices, true),\n                        centre = { x: 0, y: 0 },\n                        cross,\n                        temp,\n                        j;\n\n                    for (var i = 0; i < vertices.length; i++) {\n                        j = (i + 1) % vertices.length;\n                        cross = Vector.cross(vertices[i], vertices[j]);\n                        temp = Vector.mult(Vector.add(vertices[i], vertices[j]), cross);\n                        centre = Vector.add(centre, temp);\n                    }\n\n                    return Vector.div(centre, 6 * area);\n                };\n\n                /**\n                 * Returns the average (mean) of the set of vertices.\n                 * @method mean\n                 * @param {vertices} vertices\n                 * @return {vector} The average point\n                 */\n                Vertices.mean = function (vertices) {\n                    var average = { x: 0, y: 0 };\n\n                    for (var i = 0; i < vertices.length; i++) {\n                        average.x += vertices[i].x;\n                        average.y += vertices[i].y;\n                    }\n\n                    return Vector.div(average, vertices.length);\n                };\n\n                /**\n                 * Returns the area of the set of vertices.\n                 * @method area\n                 * @param {vertices} vertices\n                 * @param {bool} signed\n                 * @return {number} The area\n                 */\n                Vertices.area = function (vertices, signed) {\n                    var area = 0,\n                        j = vertices.length - 1;\n\n                    for (var i = 0; i < vertices.length; i++) {\n                        area += (vertices[j].x - vertices[i].x) * (vertices[j].y + vertices[i].y);\n                        j = i;\n                    }\n\n                    if (signed) return area / 2;\n\n                    return Math.abs(area) / 2;\n                };\n\n                /**\n                 * Returns the moment of inertia (second moment of area) of the set of vertices given the total mass.\n                 * @method inertia\n                 * @param {vertices} vertices\n                 * @param {number} mass\n                 * @return {number} The polygon's moment of inertia\n                 */\n                Vertices.inertia = function (vertices, mass) {\n                    var numerator = 0,\n                        denominator = 0,\n                        v = vertices,\n                        cross,\n                        j;\n\n                    // find the polygon's moment of inertia, using second moment of area\n                    // from equations at http://www.physicsforums.com/showthread.php?t=25293\n                    for (var n = 0; n < v.length; n++) {\n                        j = (n + 1) % v.length;\n                        cross = Math.abs(Vector.cross(v[j], v[n]));\n                        numerator += cross * (Vector.dot(v[j], v[j]) + Vector.dot(v[j], v[n]) + Vector.dot(v[n], v[n]));\n                        denominator += cross;\n                    }\n\n                    return mass / 6 * (numerator / denominator);\n                };\n\n                /**\n                 * Translates the set of vertices in-place.\n                 * @method translate\n                 * @param {vertices} vertices\n                 * @param {vector} vector\n                 * @param {number} scalar\n                 */\n                Vertices.translate = function (vertices, vector, scalar) {\n                    var i;\n                    if (scalar) {\n                        for (i = 0; i < vertices.length; i++) {\n                            vertices[i].x += vector.x * scalar;\n                            vertices[i].y += vector.y * scalar;\n                        }\n                    } else {\n                        for (i = 0; i < vertices.length; i++) {\n                            vertices[i].x += vector.x;\n                            vertices[i].y += vector.y;\n                        }\n                    }\n\n                    return vertices;\n                };\n\n                /**\n                 * Rotates the set of vertices in-place.\n                 * @method rotate\n                 * @param {vertices} vertices\n                 * @param {number} angle\n                 * @param {vector} point\n                 */\n                Vertices.rotate = function (vertices, angle, point) {\n                    if (angle === 0) return;\n\n                    var cos = Math.cos(angle),\n                        sin = Math.sin(angle);\n\n                    for (var i = 0; i < vertices.length; i++) {\n                        var vertice = vertices[i],\n                            dx = vertice.x - point.x,\n                            dy = vertice.y - point.y;\n\n                        vertice.x = point.x + (dx * cos - dy * sin);\n                        vertice.y = point.y + (dx * sin + dy * cos);\n                    }\n\n                    return vertices;\n                };\n\n                /**\n                 * Returns `true` if the `point` is inside the set of `vertices`.\n                 * @method contains\n                 * @param {vertices} vertices\n                 * @param {vector} point\n                 * @return {boolean} True if the vertices contains point, otherwise false\n                 */\n                Vertices.contains = function (vertices, point) {\n                    for (var i = 0; i < vertices.length; i++) {\n                        var vertice = vertices[i],\n                            nextVertice = vertices[(i + 1) % vertices.length];\n                        if ((point.x - vertice.x) * (nextVertice.y - vertice.y) + (point.y - vertice.y) * (vertice.x - nextVertice.x) > 0) {\n                            return false;\n                        }\n                    }\n\n                    return true;\n                };\n\n                /**\n                 * Scales the vertices from a point (default is centre) in-place.\n                 * @method scale\n                 * @param {vertices} vertices\n                 * @param {number} scaleX\n                 * @param {number} scaleY\n                 * @param {vector} point\n                 */\n                Vertices.scale = function (vertices, scaleX, scaleY, point) {\n                    if (scaleX === 1 && scaleY === 1) return vertices;\n\n                    point = point || Vertices.centre(vertices);\n\n                    var vertex, delta;\n\n                    for (var i = 0; i < vertices.length; i++) {\n                        vertex = vertices[i];\n                        delta = Vector.sub(vertex, point);\n                        vertices[i].x = point.x + delta.x * scaleX;\n                        vertices[i].y = point.y + delta.y * scaleY;\n                    }\n\n                    return vertices;\n                };\n\n                /**\n                 * Chamfers a set of vertices by giving them rounded corners, returns a new set of vertices.\n                 * The radius parameter is a single number or an array to specify the radius for each vertex.\n                 * @method chamfer\n                 * @param {vertices} vertices\n                 * @param {number[]} radius\n                 * @param {number} quality\n                 * @param {number} qualityMin\n                 * @param {number} qualityMax\n                 */\n                Vertices.chamfer = function (vertices, radius, quality, qualityMin, qualityMax) {\n                    if (typeof radius === 'number') {\n                        radius = [radius];\n                    } else {\n                        radius = radius || [8];\n                    }\n\n                    // quality defaults to -1, which is auto\n                    quality = typeof quality !== 'undefined' ? quality : -1;\n                    qualityMin = qualityMin || 2;\n                    qualityMax = qualityMax || 14;\n\n                    var newVertices = [];\n\n                    for (var i = 0; i < vertices.length; i++) {\n                        var prevVertex = vertices[i - 1 >= 0 ? i - 1 : vertices.length - 1],\n                            vertex = vertices[i],\n                            nextVertex = vertices[(i + 1) % vertices.length],\n                            currentRadius = radius[i < radius.length ? i : radius.length - 1];\n\n                        if (currentRadius === 0) {\n                            newVertices.push(vertex);\n                            continue;\n                        }\n\n                        var prevNormal = Vector.normalise({\n                            x: vertex.y - prevVertex.y,\n                            y: prevVertex.x - vertex.x\n                        });\n\n                        var nextNormal = Vector.normalise({\n                            x: nextVertex.y - vertex.y,\n                            y: vertex.x - nextVertex.x\n                        });\n\n                        var diagonalRadius = Math.sqrt(2 * Math.pow(currentRadius, 2)),\n                            radiusVector = Vector.mult(Common.clone(prevNormal), currentRadius),\n                            midNormal = Vector.normalise(Vector.mult(Vector.add(prevNormal, nextNormal), 0.5)),\n                            scaledVertex = Vector.sub(vertex, Vector.mult(midNormal, diagonalRadius));\n\n                        var precision = quality;\n\n                        if (quality === -1) {\n                            // automatically decide precision\n                            precision = Math.pow(currentRadius, 0.32) * 1.75;\n                        }\n\n                        precision = Common.clamp(precision, qualityMin, qualityMax);\n\n                        // use an even value for precision, more likely to reduce axes by using symmetry\n                        if (precision % 2 === 1) precision += 1;\n\n                        var alpha = Math.acos(Vector.dot(prevNormal, nextNormal)),\n                            theta = alpha / precision;\n\n                        for (var j = 0; j < precision; j++) {\n                            newVertices.push(Vector.add(Vector.rotate(radiusVector, theta * j), scaledVertex));\n                        }\n                    }\n\n                    return newVertices;\n                };\n\n                /**\n                 * Sorts the input vertices into clockwise order in place.\n                 * @method clockwiseSort\n                 * @param {vertices} vertices\n                 * @return {vertices} vertices\n                 */\n                Vertices.clockwiseSort = function (vertices) {\n                    var centre = Vertices.mean(vertices);\n\n                    vertices.sort(function (vertexA, vertexB) {\n                        return Vector.angle(centre, vertexA) - Vector.angle(centre, vertexB);\n                    });\n\n                    return vertices;\n                };\n\n                /**\n                 * Returns true if the vertices form a convex shape (vertices must be in clockwise order).\n                 * @method isConvex\n                 * @param {vertices} vertices\n                 * @return {bool} `true` if the `vertices` are convex, `false` if not (or `null` if not computable).\n                 */\n                Vertices.isConvex = function (vertices) {\n                    // http://paulbourke.net/geometry/polygonmesh/\n                    // Copyright (c) Paul Bourke (use permitted)\n\n                    var flag = 0,\n                        n = vertices.length,\n                        i,\n                        j,\n                        k,\n                        z;\n\n                    if (n < 3) return null;\n\n                    for (i = 0; i < n; i++) {\n                        j = (i + 1) % n;\n                        k = (i + 2) % n;\n                        z = (vertices[j].x - vertices[i].x) * (vertices[k].y - vertices[j].y);\n                        z -= (vertices[j].y - vertices[i].y) * (vertices[k].x - vertices[j].x);\n\n                        if (z < 0) {\n                            flag |= 1;\n                        } else if (z > 0) {\n                            flag |= 2;\n                        }\n\n                        if (flag === 3) {\n                            return false;\n                        }\n                    }\n\n                    if (flag !== 0) {\n                        return true;\n                    } else {\n                        return null;\n                    }\n                };\n\n                /**\n                 * Returns the convex hull of the input vertices as a new array of points.\n                 * @method hull\n                 * @param {vertices} vertices\n                 * @return [vertex] vertices\n                 */\n                Vertices.hull = function (vertices) {\n                    // http://geomalgorithms.com/a10-_hull-1.html\n\n                    var upper = [],\n                        lower = [],\n                        vertex,\n                        i;\n\n                    // sort vertices on x-axis (y-axis for ties)\n                    vertices = vertices.slice(0);\n                    vertices.sort(function (vertexA, vertexB) {\n                        var dx = vertexA.x - vertexB.x;\n                        return dx !== 0 ? dx : vertexA.y - vertexB.y;\n                    });\n\n                    // build lower hull\n                    for (i = 0; i < vertices.length; i += 1) {\n                        vertex = vertices[i];\n\n                        while (lower.length >= 2 && Vector.cross3(lower[lower.length - 2], lower[lower.length - 1], vertex) <= 0) {\n                            lower.pop();\n                        }\n\n                        lower.push(vertex);\n                    }\n\n                    // build upper hull\n                    for (i = vertices.length - 1; i >= 0; i -= 1) {\n                        vertex = vertices[i];\n\n                        while (upper.length >= 2 && Vector.cross3(upper[upper.length - 2], upper[upper.length - 1], vertex) <= 0) {\n                            upper.pop();\n                        }\n\n                        upper.push(vertex);\n                    }\n\n                    // concatenation of the lower and upper hulls gives the convex hull\n                    // omit last points because they are repeated at the beginning of the other list\n                    upper.pop();\n                    lower.pop();\n\n                    return upper.concat(lower);\n                };\n            })();\n        }, { \"../core/Common\": 14, \"../geometry/Vector\": 28 }], 30: [function (_dereq_, module, exports) {\n            var Matter = module.exports = _dereq_('../core/Matter');\n\n            Matter.Body = _dereq_('../body/Body');\n            Matter.Composite = _dereq_('../body/Composite');\n            Matter.World = _dereq_('../body/World');\n\n            Matter.Contact = _dereq_('../collision/Contact');\n            Matter.Detector = _dereq_('../collision/Detector');\n            Matter.Grid = _dereq_('../collision/Grid');\n            Matter.Pairs = _dereq_('../collision/Pairs');\n            Matter.Pair = _dereq_('../collision/Pair');\n            Matter.Query = _dereq_('../collision/Query');\n            Matter.Resolver = _dereq_('../collision/Resolver');\n            Matter.SAT = _dereq_('../collision/SAT');\n\n            Matter.Constraint = _dereq_('../constraint/Constraint');\n            Matter.MouseConstraint = _dereq_('../constraint/MouseConstraint');\n\n            Matter.Common = _dereq_('../core/Common');\n            Matter.Engine = _dereq_('../core/Engine');\n            Matter.Events = _dereq_('../core/Events');\n            Matter.Mouse = _dereq_('../core/Mouse');\n            Matter.Runner = _dereq_('../core/Runner');\n            Matter.Sleeping = _dereq_('../core/Sleeping');\n            Matter.Plugin = _dereq_('../core/Plugin');\n\n            Matter.Bodies = _dereq_('../factory/Bodies');\n            Matter.Composites = _dereq_('../factory/Composites');\n\n            Matter.Axes = _dereq_('../geometry/Axes');\n            Matter.Bounds = _dereq_('../geometry/Bounds');\n            Matter.Svg = _dereq_('../geometry/Svg');\n            Matter.Vector = _dereq_('../geometry/Vector');\n            Matter.Vertices = _dereq_('../geometry/Vertices');\n\n            Matter.Render = _dereq_('../render/Render');\n            Matter.RenderPixi = _dereq_('../render/RenderPixi');\n\n            // aliases\n\n            Matter.World.add = Matter.Composite.add;\n            Matter.World.remove = Matter.Composite.remove;\n            Matter.World.addComposite = Matter.Composite.addComposite;\n            Matter.World.addBody = Matter.Composite.addBody;\n            Matter.World.addConstraint = Matter.Composite.addConstraint;\n            Matter.World.clear = Matter.Composite.clear;\n            Matter.Engine.run = Matter.Runner.run;\n        }, { \"../body/Body\": 1, \"../body/Composite\": 2, \"../body/World\": 3, \"../collision/Contact\": 4, \"../collision/Detector\": 5, \"../collision/Grid\": 6, \"../collision/Pair\": 7, \"../collision/Pairs\": 8, \"../collision/Query\": 9, \"../collision/Resolver\": 10, \"../collision/SAT\": 11, \"../constraint/Constraint\": 12, \"../constraint/MouseConstraint\": 13, \"../core/Common\": 14, \"../core/Engine\": 15, \"../core/Events\": 16, \"../core/Matter\": 17, \"../core/Metrics\": 18, \"../core/Mouse\": 19, \"../core/Plugin\": 20, \"../core/Runner\": 21, \"../core/Sleeping\": 22, \"../factory/Bodies\": 23, \"../factory/Composites\": 24, \"../geometry/Axes\": 25, \"../geometry/Bounds\": 26, \"../geometry/Svg\": 27, \"../geometry/Vector\": 28, \"../geometry/Vertices\": 29, \"../render/Render\": 31, \"../render/RenderPixi\": 32 }], 31: [function (_dereq_, module, exports) {\n            /**\n            * The `Matter.Render` module is a simple HTML5 canvas based renderer for visualising instances of `Matter.Engine`.\n            * It is intended for development and debugging purposes, but may also be suitable for simple games.\n            * It includes a number of drawing options including wireframe, vector with support for sprites and viewports.\n            *\n            * @class Render\n            */\n\n            var Render = {};\n\n            module.exports = Render;\n\n            var Common = _dereq_('../core/Common');\n            var Composite = _dereq_('../body/Composite');\n            var Bounds = _dereq_('../geometry/Bounds');\n            var Events = _dereq_('../core/Events');\n            var Grid = _dereq_('../collision/Grid');\n            var Vector = _dereq_('../geometry/Vector');\n            var Mouse = _dereq_('../core/Mouse');\n\n            (function () {\n\n                var _requestAnimationFrame, _cancelAnimationFrame;\n\n                if (typeof window !== 'undefined') {\n                    _requestAnimationFrame = window.requestAnimationFrame || window.webkitRequestAnimationFrame || window.mozRequestAnimationFrame || window.msRequestAnimationFrame || function (callback) {\n                        window.setTimeout(function () {\n                            callback(Common.now());\n                        }, 1000 / 60);\n                    };\n\n                    _cancelAnimationFrame = window.cancelAnimationFrame || window.mozCancelAnimationFrame || window.webkitCancelAnimationFrame || window.msCancelAnimationFrame;\n                }\n\n                /**\n                 * Creates a new renderer. The options parameter is an object that specifies any properties you wish to override the defaults.\n                 * All properties have default values, and many are pre-calculated automatically based on other properties.\n                 * See the properties section below for detailed information on what you can pass via the `options` object.\n                 * @method create\n                 * @param {object} [options]\n                 * @return {render} A new renderer\n                 */\n                Render.create = function (options) {\n                    var defaults = {\n                        controller: Render,\n                        engine: null,\n                        element: null,\n                        canvas: null,\n                        mouse: null,\n                        frameRequestId: null,\n                        options: {\n                            width: 800,\n                            height: 600,\n                            pixelRatio: 1,\n                            background: '#18181d',\n                            wireframeBackground: '#0f0f13',\n                            hasBounds: !!options.bounds,\n                            enabled: true,\n                            wireframes: true,\n                            showSleeping: true,\n                            showDebug: false,\n                            showBroadphase: false,\n                            showBounds: false,\n                            showVelocity: false,\n                            showCollisions: false,\n                            showSeparations: false,\n                            showAxes: false,\n                            showPositions: false,\n                            showAngleIndicator: false,\n                            showIds: false,\n                            showShadows: false,\n                            showVertexNumbers: false,\n                            showConvexHulls: false,\n                            showInternalEdges: false,\n                            showMousePosition: false\n                        }\n                    };\n\n                    var render = Common.extend(defaults, options);\n\n                    if (render.canvas) {\n                        render.canvas.width = render.options.width || render.canvas.width;\n                        render.canvas.height = render.options.height || render.canvas.height;\n                    }\n\n                    render.mouse = options.mouse;\n                    render.engine = options.engine;\n                    render.canvas = render.canvas || _createCanvas(render.options.width, render.options.height);\n                    render.context = render.canvas.getContext('2d');\n                    render.textures = {};\n\n                    render.bounds = render.bounds || {\n                        min: {\n                            x: 0,\n                            y: 0\n                        },\n                        max: {\n                            x: render.canvas.width,\n                            y: render.canvas.height\n                        }\n                    };\n\n                    if (render.options.pixelRatio !== 1) {\n                        Render.setPixelRatio(render, render.options.pixelRatio);\n                    }\n\n                    if (Common.isElement(render.element)) {\n                        render.element.appendChild(render.canvas);\n                    } else if (!render.canvas.parentNode) {\n                        Common.log('Render.create: options.element was undefined, render.canvas was created but not appended', 'warn');\n                    }\n\n                    return render;\n                };\n\n                /**\n                 * Continuously updates the render canvas on the `requestAnimationFrame` event.\n                 * @method run\n                 * @param {render} render\n                 */\n                Render.run = function (render) {\n                    (function loop(time) {\n                        render.frameRequestId = _requestAnimationFrame(loop);\n                        Render.world(render);\n                    })();\n                };\n\n                /**\n                 * Ends execution of `Render.run` on the given `render`, by canceling the animation frame request event loop.\n                 * @method stop\n                 * @param {render} render\n                 */\n                Render.stop = function (render) {\n                    _cancelAnimationFrame(render.frameRequestId);\n                };\n\n                /**\n                 * Sets the pixel ratio of the renderer and updates the canvas.\n                 * To automatically detect the correct ratio, pass the string `'auto'` for `pixelRatio`.\n                 * @method setPixelRatio\n                 * @param {render} render\n                 * @param {number} pixelRatio\n                 */\n                Render.setPixelRatio = function (render, pixelRatio) {\n                    var options = render.options,\n                        canvas = render.canvas;\n\n                    if (pixelRatio === 'auto') {\n                        pixelRatio = _getPixelRatio(canvas);\n                    }\n\n                    options.pixelRatio = pixelRatio;\n                    canvas.setAttribute('data-pixel-ratio', pixelRatio);\n                    canvas.width = options.width * pixelRatio;\n                    canvas.height = options.height * pixelRatio;\n                    canvas.style.width = options.width + 'px';\n                    canvas.style.height = options.height + 'px';\n                    render.context.scale(pixelRatio, pixelRatio);\n                };\n\n                /**\n                 * Positions and sizes the viewport around the given object bounds.\n                 * Objects must have at least one of the following properties:\n                 * - `object.bounds`\n                 * - `object.position`\n                 * - `object.min` and `object.max`\n                 * - `object.x` and `object.y`\n                 * @method lookAt\n                 * @param {render} render\n                 * @param {object[]} objects\n                 * @param {vector} [padding]\n                 * @param {bool} [center=true]\n                 */\n                Render.lookAt = function (render, objects, padding, center) {\n                    center = typeof center !== 'undefined' ? center : true;\n                    objects = Common.isArray(objects) ? objects : [objects];\n                    padding = padding || {\n                        x: 0,\n                        y: 0\n                    };\n\n                    // find bounds of all objects\n                    var bounds = {\n                        min: { x: Infinity, y: Infinity },\n                        max: { x: -Infinity, y: -Infinity }\n                    };\n\n                    for (var i = 0; i < objects.length; i += 1) {\n                        var object = objects[i],\n                            min = object.bounds ? object.bounds.min : object.min || object.position || object,\n                            max = object.bounds ? object.bounds.max : object.max || object.position || object;\n\n                        if (min && max) {\n                            if (min.x < bounds.min.x) bounds.min.x = min.x;\n\n                            if (max.x > bounds.max.x) bounds.max.x = max.x;\n\n                            if (min.y < bounds.min.y) bounds.min.y = min.y;\n\n                            if (max.y > bounds.max.y) bounds.max.y = max.y;\n                        }\n                    }\n\n                    // find ratios\n                    var width = bounds.max.x - bounds.min.x + 2 * padding.x,\n                        height = bounds.max.y - bounds.min.y + 2 * padding.y,\n                        viewHeight = render.canvas.height,\n                        viewWidth = render.canvas.width,\n                        outerRatio = viewWidth / viewHeight,\n                        innerRatio = width / height,\n                        scaleX = 1,\n                        scaleY = 1;\n\n                    // find scale factor\n                    if (innerRatio > outerRatio) {\n                        scaleY = innerRatio / outerRatio;\n                    } else {\n                        scaleX = outerRatio / innerRatio;\n                    }\n\n                    // enable bounds\n                    render.options.hasBounds = true;\n\n                    // position and size\n                    render.bounds.min.x = bounds.min.x;\n                    render.bounds.max.x = bounds.min.x + width * scaleX;\n                    render.bounds.min.y = bounds.min.y;\n                    render.bounds.max.y = bounds.min.y + height * scaleY;\n\n                    // center\n                    if (center) {\n                        render.bounds.min.x += width * 0.5 - width * scaleX * 0.5;\n                        render.bounds.max.x += width * 0.5 - width * scaleX * 0.5;\n                        render.bounds.min.y += height * 0.5 - height * scaleY * 0.5;\n                        render.bounds.max.y += height * 0.5 - height * scaleY * 0.5;\n                    }\n\n                    // padding\n                    render.bounds.min.x -= padding.x;\n                    render.bounds.max.x -= padding.x;\n                    render.bounds.min.y -= padding.y;\n                    render.bounds.max.y -= padding.y;\n\n                    // update mouse\n                    if (render.mouse) {\n                        Mouse.setScale(render.mouse, {\n                            x: (render.bounds.max.x - render.bounds.min.x) / render.canvas.width,\n                            y: (render.bounds.max.y - render.bounds.min.y) / render.canvas.height\n                        });\n\n                        Mouse.setOffset(render.mouse, render.bounds.min);\n                    }\n                };\n\n                /**\n                 * Applies viewport transforms based on `render.bounds` to a render context.\n                 * @method startViewTransform\n                 * @param {render} render\n                 */\n                Render.startViewTransform = function (render) {\n                    var boundsWidth = render.bounds.max.x - render.bounds.min.x,\n                        boundsHeight = render.bounds.max.y - render.bounds.min.y,\n                        boundsScaleX = boundsWidth / render.options.width,\n                        boundsScaleY = boundsHeight / render.options.height;\n\n                    render.context.scale(1 / boundsScaleX, 1 / boundsScaleY);\n                    render.context.translate(-render.bounds.min.x, -render.bounds.min.y);\n                };\n\n                /**\n                 * Resets all transforms on the render context.\n                 * @method endViewTransform\n                 * @param {render} render\n                 */\n                Render.endViewTransform = function (render) {\n                    render.context.setTransform(render.options.pixelRatio, 0, 0, render.options.pixelRatio, 0, 0);\n                };\n\n                /**\n                 * Renders the given `engine`'s `Matter.World` object.\n                 * This is the entry point for all rendering and should be called every time the scene changes.\n                 * @method world\n                 * @param {render} render\n                 */\n                Render.world = function (render) {\n                    var engine = render.engine,\n                        world = engine.world,\n                        canvas = render.canvas,\n                        context = render.context,\n                        options = render.options,\n                        allBodies = Composite.allBodies(world),\n                        allConstraints = Composite.allConstraints(world),\n                        background = options.wireframes ? options.wireframeBackground : options.background,\n                        bodies = [],\n                        constraints = [],\n                        i;\n\n                    var event = {\n                        timestamp: engine.timing.timestamp\n                    };\n\n                    Events.trigger(render, 'beforeRender', event);\n\n                    // apply background if it has changed\n                    if (render.currentBackground !== background) _applyBackground(render, background);\n\n                    // clear the canvas with a transparent fill, to allow the canvas background to show\n                    context.globalCompositeOperation = 'source-in';\n                    context.fillStyle = \"transparent\";\n                    context.fillRect(0, 0, canvas.width, canvas.height);\n                    context.globalCompositeOperation = 'source-over';\n\n                    // handle bounds\n                    if (options.hasBounds) {\n                        // filter out bodies that are not in view\n                        for (i = 0; i < allBodies.length; i++) {\n                            var body = allBodies[i];\n                            if (Bounds.overlaps(body.bounds, render.bounds)) bodies.push(body);\n                        }\n\n                        // filter out constraints that are not in view\n                        for (i = 0; i < allConstraints.length; i++) {\n                            var constraint = allConstraints[i],\n                                bodyA = constraint.bodyA,\n                                bodyB = constraint.bodyB,\n                                pointAWorld = constraint.pointA,\n                                pointBWorld = constraint.pointB;\n\n                            if (bodyA) pointAWorld = Vector.add(bodyA.position, constraint.pointA);\n                            if (bodyB) pointBWorld = Vector.add(bodyB.position, constraint.pointB);\n\n                            if (!pointAWorld || !pointBWorld) continue;\n\n                            if (Bounds.contains(render.bounds, pointAWorld) || Bounds.contains(render.bounds, pointBWorld)) constraints.push(constraint);\n                        }\n\n                        // transform the view\n                        Render.startViewTransform(render);\n\n                        // update mouse\n                        if (render.mouse) {\n                            Mouse.setScale(render.mouse, {\n                                x: (render.bounds.max.x - render.bounds.min.x) / render.canvas.width,\n                                y: (render.bounds.max.y - render.bounds.min.y) / render.canvas.height\n                            });\n\n                            Mouse.setOffset(render.mouse, render.bounds.min);\n                        }\n                    } else {\n                        constraints = allConstraints;\n                        bodies = allBodies;\n                    }\n\n                    if (!options.wireframes || engine.enableSleeping && options.showSleeping) {\n                        // fully featured rendering of bodies\n                        Render.bodies(render, bodies, context);\n                    } else {\n                        if (options.showConvexHulls) Render.bodyConvexHulls(render, bodies, context);\n\n                        // optimised method for wireframes only\n                        Render.bodyWireframes(render, bodies, context);\n                    }\n\n                    if (options.showBounds) Render.bodyBounds(render, bodies, context);\n\n                    if (options.showAxes || options.showAngleIndicator) Render.bodyAxes(render, bodies, context);\n\n                    if (options.showPositions) Render.bodyPositions(render, bodies, context);\n\n                    if (options.showVelocity) Render.bodyVelocity(render, bodies, context);\n\n                    if (options.showIds) Render.bodyIds(render, bodies, context);\n\n                    if (options.showSeparations) Render.separations(render, engine.pairs.list, context);\n\n                    if (options.showCollisions) Render.collisions(render, engine.pairs.list, context);\n\n                    if (options.showVertexNumbers) Render.vertexNumbers(render, bodies, context);\n\n                    if (options.showMousePosition) Render.mousePosition(render, render.mouse, context);\n\n                    Render.constraints(constraints, context);\n\n                    if (options.showBroadphase && engine.broadphase.controller === Grid) Render.grid(render, engine.broadphase, context);\n\n                    if (options.showDebug) Render.debug(render, context);\n\n                    if (options.hasBounds) {\n                        // revert view transforms\n                        Render.endViewTransform(render);\n                    }\n\n                    Events.trigger(render, 'afterRender', event);\n                };\n\n                /**\n                 * Description\n                 * @private\n                 * @method debug\n                 * @param {render} render\n                 * @param {RenderingContext} context\n                 */\n                Render.debug = function (render, context) {\n                    var c = context,\n                        engine = render.engine,\n                        world = engine.world,\n                        metrics = engine.metrics,\n                        options = render.options,\n                        bodies = Composite.allBodies(world),\n                        space = \"    \";\n\n                    if (engine.timing.timestamp - (render.debugTimestamp || 0) >= 500) {\n                        var text = \"\";\n\n                        if (metrics.timing) {\n                            text += \"fps: \" + Math.round(metrics.timing.fps) + space;\n                        }\n\n                        render.debugString = text;\n                        render.debugTimestamp = engine.timing.timestamp;\n                    }\n\n                    if (render.debugString) {\n                        c.font = \"12px Arial\";\n\n                        if (options.wireframes) {\n                            c.fillStyle = 'rgba(255,255,255,0.5)';\n                        } else {\n                            c.fillStyle = 'rgba(0,0,0,0.5)';\n                        }\n\n                        var split = render.debugString.split('\\n');\n\n                        for (var i = 0; i < split.length; i++) {\n                            c.fillText(split[i], 50, 50 + i * 18);\n                        }\n                    }\n                };\n\n                /**\n                 * Description\n                 * @private\n                 * @method constraints\n                 * @param {constraint[]} constraints\n                 * @param {RenderingContext} context\n                 */\n                Render.constraints = function (constraints, context) {\n                    var c = context;\n\n                    for (var i = 0; i < constraints.length; i++) {\n                        var constraint = constraints[i];\n\n                        if (!constraint.render.visible || !constraint.pointA || !constraint.pointB) continue;\n\n                        var bodyA = constraint.bodyA,\n                            bodyB = constraint.bodyB,\n                            start,\n                            end;\n\n                        if (bodyA) {\n                            start = Vector.add(bodyA.position, constraint.pointA);\n                        } else {\n                            start = constraint.pointA;\n                        }\n\n                        if (constraint.render.type === 'pin') {\n                            c.beginPath();\n                            c.arc(start.x, start.y, 3, 0, 2 * Math.PI);\n                            c.closePath();\n                        } else {\n                            if (bodyB) {\n                                end = Vector.add(bodyB.position, constraint.pointB);\n                            } else {\n                                end = constraint.pointB;\n                            }\n\n                            c.beginPath();\n                            c.moveTo(start.x, start.y);\n\n                            if (constraint.render.type === 'spring') {\n                                var delta = Vector.sub(end, start),\n                                    normal = Vector.perp(Vector.normalise(delta)),\n                                    coils = Math.ceil(Common.clamp(constraint.length / 5, 12, 20)),\n                                    offset;\n\n                                for (var j = 1; j < coils; j += 1) {\n                                    offset = j % 2 === 0 ? 1 : -1;\n\n                                    c.lineTo(start.x + delta.x * (j / coils) + normal.x * offset * 4, start.y + delta.y * (j / coils) + normal.y * offset * 4);\n                                }\n                            }\n\n                            c.lineTo(end.x, end.y);\n                        }\n\n                        if (constraint.render.lineWidth) {\n                            c.lineWidth = constraint.render.lineWidth;\n                            c.strokeStyle = constraint.render.strokeStyle;\n                            c.stroke();\n                        }\n\n                        if (constraint.render.anchors) {\n                            c.fillStyle = constraint.render.strokeStyle;\n                            c.beginPath();\n                            c.arc(start.x, start.y, 3, 0, 2 * Math.PI);\n                            c.arc(end.x, end.y, 3, 0, 2 * Math.PI);\n                            c.closePath();\n                            c.fill();\n                        }\n                    }\n                };\n\n                /**\n                 * Description\n                 * @private\n                 * @method bodyShadows\n                 * @param {render} render\n                 * @param {body[]} bodies\n                 * @param {RenderingContext} context\n                 */\n                Render.bodyShadows = function (render, bodies, context) {\n                    var c = context,\n                        engine = render.engine;\n\n                    for (var i = 0; i < bodies.length; i++) {\n                        var body = bodies[i];\n\n                        if (!body.render.visible) continue;\n\n                        if (body.circleRadius) {\n                            c.beginPath();\n                            c.arc(body.position.x, body.position.y, body.circleRadius, 0, 2 * Math.PI);\n                            c.closePath();\n                        } else {\n                            c.beginPath();\n                            c.moveTo(body.vertices[0].x, body.vertices[0].y);\n                            for (var j = 1; j < body.vertices.length; j++) {\n                                c.lineTo(body.vertices[j].x, body.vertices[j].y);\n                            }\n                            c.closePath();\n                        }\n\n                        var distanceX = body.position.x - render.options.width * 0.5,\n                            distanceY = body.position.y - render.options.height * 0.2,\n                            distance = Math.abs(distanceX) + Math.abs(distanceY);\n\n                        c.shadowColor = 'rgba(0,0,0,0.15)';\n                        c.shadowOffsetX = 0.05 * distanceX;\n                        c.shadowOffsetY = 0.05 * distanceY;\n                        c.shadowBlur = 1 + 12 * Math.min(1, distance / 1000);\n\n                        c.fill();\n\n                        c.shadowColor = null;\n                        c.shadowOffsetX = null;\n                        c.shadowOffsetY = null;\n                        c.shadowBlur = null;\n                    }\n                };\n\n                /**\n                 * Description\n                 * @private\n                 * @method bodies\n                 * @param {render} render\n                 * @param {body[]} bodies\n                 * @param {RenderingContext} context\n                 */\n                Render.bodies = function (render, bodies, context) {\n                    var c = context,\n                        engine = render.engine,\n                        options = render.options,\n                        showInternalEdges = options.showInternalEdges || !options.wireframes,\n                        body,\n                        part,\n                        i,\n                        k;\n\n                    for (i = 0; i < bodies.length; i++) {\n                        body = bodies[i];\n\n                        if (!body.render.visible) continue;\n\n                        // handle compound parts\n                        for (k = body.parts.length > 1 ? 1 : 0; k < body.parts.length; k++) {\n                            part = body.parts[k];\n\n                            if (!part.render.visible) continue;\n\n                            if (options.showSleeping && body.isSleeping) {\n                                c.globalAlpha = 0.5 * part.render.opacity;\n                            } else if (part.render.opacity !== 1) {\n                                c.globalAlpha = part.render.opacity;\n                            }\n\n                            if (part.render.sprite && part.render.sprite.texture && !options.wireframes) {\n                                // part sprite\n                                var sprite = part.render.sprite,\n                                    texture = _getTexture(render, sprite.texture);\n\n                                c.translate(part.position.x, part.position.y);\n                                c.rotate(part.angle);\n\n                                c.drawImage(texture, texture.width * -sprite.xOffset * sprite.xScale, texture.height * -sprite.yOffset * sprite.yScale, texture.width * sprite.xScale, texture.height * sprite.yScale);\n\n                                // revert translation, hopefully faster than save / restore\n                                c.rotate(-part.angle);\n                                c.translate(-part.position.x, -part.position.y);\n                            } else {\n                                // part polygon\n                                if (part.circleRadius) {\n                                    c.beginPath();\n                                    c.arc(part.position.x, part.position.y, part.circleRadius, 0, 2 * Math.PI);\n                                } else {\n                                    c.beginPath();\n                                    c.moveTo(part.vertices[0].x, part.vertices[0].y);\n\n                                    for (var j = 1; j < part.vertices.length; j++) {\n                                        if (!part.vertices[j - 1].isInternal || showInternalEdges) {\n                                            c.lineTo(part.vertices[j].x, part.vertices[j].y);\n                                        } else {\n                                            c.moveTo(part.vertices[j].x, part.vertices[j].y);\n                                        }\n\n                                        if (part.vertices[j].isInternal && !showInternalEdges) {\n                                            c.moveTo(part.vertices[(j + 1) % part.vertices.length].x, part.vertices[(j + 1) % part.vertices.length].y);\n                                        }\n                                    }\n\n                                    c.lineTo(part.vertices[0].x, part.vertices[0].y);\n                                    c.closePath();\n                                }\n\n                                if (!options.wireframes) {\n                                    c.fillStyle = part.render.fillStyle;\n\n                                    if (part.render.lineWidth) {\n                                        c.lineWidth = part.render.lineWidth;\n                                        c.strokeStyle = part.render.strokeStyle;\n                                        c.stroke();\n                                    }\n\n                                    c.fill();\n                                } else {\n                                    c.lineWidth = 1;\n                                    c.strokeStyle = '#bbb';\n                                    c.stroke();\n                                }\n                            }\n\n                            c.globalAlpha = 1;\n                        }\n                    }\n                };\n\n                /**\n                 * Optimised method for drawing body wireframes in one pass\n                 * @private\n                 * @method bodyWireframes\n                 * @param {render} render\n                 * @param {body[]} bodies\n                 * @param {RenderingContext} context\n                 */\n                Render.bodyWireframes = function (render, bodies, context) {\n                    var c = context,\n                        showInternalEdges = render.options.showInternalEdges,\n                        body,\n                        part,\n                        i,\n                        j,\n                        k;\n\n                    c.beginPath();\n\n                    // render all bodies\n                    for (i = 0; i < bodies.length; i++) {\n                        body = bodies[i];\n\n                        if (!body.render.visible) continue;\n\n                        // handle compound parts\n                        for (k = body.parts.length > 1 ? 1 : 0; k < body.parts.length; k++) {\n                            part = body.parts[k];\n\n                            c.moveTo(part.vertices[0].x, part.vertices[0].y);\n\n                            for (j = 1; j < part.vertices.length; j++) {\n                                if (!part.vertices[j - 1].isInternal || showInternalEdges) {\n                                    c.lineTo(part.vertices[j].x, part.vertices[j].y);\n                                } else {\n                                    c.moveTo(part.vertices[j].x, part.vertices[j].y);\n                                }\n\n                                if (part.vertices[j].isInternal && !showInternalEdges) {\n                                    c.moveTo(part.vertices[(j + 1) % part.vertices.length].x, part.vertices[(j + 1) % part.vertices.length].y);\n                                }\n                            }\n\n                            c.lineTo(part.vertices[0].x, part.vertices[0].y);\n                        }\n                    }\n\n                    c.lineWidth = 1;\n                    c.strokeStyle = '#bbb';\n                    c.stroke();\n                };\n\n                /**\n                 * Optimised method for drawing body convex hull wireframes in one pass\n                 * @private\n                 * @method bodyConvexHulls\n                 * @param {render} render\n                 * @param {body[]} bodies\n                 * @param {RenderingContext} context\n                 */\n                Render.bodyConvexHulls = function (render, bodies, context) {\n                    var c = context,\n                        body,\n                        part,\n                        i,\n                        j,\n                        k;\n\n                    c.beginPath();\n\n                    // render convex hulls\n                    for (i = 0; i < bodies.length; i++) {\n                        body = bodies[i];\n\n                        if (!body.render.visible || body.parts.length === 1) continue;\n\n                        c.moveTo(body.vertices[0].x, body.vertices[0].y);\n\n                        for (j = 1; j < body.vertices.length; j++) {\n                            c.lineTo(body.vertices[j].x, body.vertices[j].y);\n                        }\n\n                        c.lineTo(body.vertices[0].x, body.vertices[0].y);\n                    }\n\n                    c.lineWidth = 1;\n                    c.strokeStyle = 'rgba(255,255,255,0.2)';\n                    c.stroke();\n                };\n\n                /**\n                 * Renders body vertex numbers.\n                 * @private\n                 * @method vertexNumbers\n                 * @param {render} render\n                 * @param {body[]} bodies\n                 * @param {RenderingContext} context\n                 */\n                Render.vertexNumbers = function (render, bodies, context) {\n                    var c = context,\n                        i,\n                        j,\n                        k;\n\n                    for (i = 0; i < bodies.length; i++) {\n                        var parts = bodies[i].parts;\n                        for (k = parts.length > 1 ? 1 : 0; k < parts.length; k++) {\n                            var part = parts[k];\n                            for (j = 0; j < part.vertices.length; j++) {\n                                c.fillStyle = 'rgba(255,255,255,0.2)';\n                                c.fillText(i + '_' + j, part.position.x + (part.vertices[j].x - part.position.x) * 0.8, part.position.y + (part.vertices[j].y - part.position.y) * 0.8);\n                            }\n                        }\n                    }\n                };\n\n                /**\n                 * Renders mouse position.\n                 * @private\n                 * @method mousePosition\n                 * @param {render} render\n                 * @param {mouse} mouse\n                 * @param {RenderingContext} context\n                 */\n                Render.mousePosition = function (render, mouse, context) {\n                    var c = context;\n                    c.fillStyle = 'rgba(255,255,255,0.8)';\n                    c.fillText(mouse.position.x + '  ' + mouse.position.y, mouse.position.x + 5, mouse.position.y - 5);\n                };\n\n                /**\n                 * Draws body bounds\n                 * @private\n                 * @method bodyBounds\n                 * @param {render} render\n                 * @param {body[]} bodies\n                 * @param {RenderingContext} context\n                 */\n                Render.bodyBounds = function (render, bodies, context) {\n                    var c = context,\n                        engine = render.engine,\n                        options = render.options;\n\n                    c.beginPath();\n\n                    for (var i = 0; i < bodies.length; i++) {\n                        var body = bodies[i];\n\n                        if (body.render.visible) {\n                            var parts = bodies[i].parts;\n                            for (var j = parts.length > 1 ? 1 : 0; j < parts.length; j++) {\n                                var part = parts[j];\n                                c.rect(part.bounds.min.x, part.bounds.min.y, part.bounds.max.x - part.bounds.min.x, part.bounds.max.y - part.bounds.min.y);\n                            }\n                        }\n                    }\n\n                    if (options.wireframes) {\n                        c.strokeStyle = 'rgba(255,255,255,0.08)';\n                    } else {\n                        c.strokeStyle = 'rgba(0,0,0,0.1)';\n                    }\n\n                    c.lineWidth = 1;\n                    c.stroke();\n                };\n\n                /**\n                 * Draws body angle indicators and axes\n                 * @private\n                 * @method bodyAxes\n                 * @param {render} render\n                 * @param {body[]} bodies\n                 * @param {RenderingContext} context\n                 */\n                Render.bodyAxes = function (render, bodies, context) {\n                    var c = context,\n                        engine = render.engine,\n                        options = render.options,\n                        part,\n                        i,\n                        j,\n                        k;\n\n                    c.beginPath();\n\n                    for (i = 0; i < bodies.length; i++) {\n                        var body = bodies[i],\n                            parts = body.parts;\n\n                        if (!body.render.visible) continue;\n\n                        if (options.showAxes) {\n                            // render all axes\n                            for (j = parts.length > 1 ? 1 : 0; j < parts.length; j++) {\n                                part = parts[j];\n                                for (k = 0; k < part.axes.length; k++) {\n                                    var axis = part.axes[k];\n                                    c.moveTo(part.position.x, part.position.y);\n                                    c.lineTo(part.position.x + axis.x * 20, part.position.y + axis.y * 20);\n                                }\n                            }\n                        } else {\n                            for (j = parts.length > 1 ? 1 : 0; j < parts.length; j++) {\n                                part = parts[j];\n                                for (k = 0; k < part.axes.length; k++) {\n                                    // render a single axis indicator\n                                    c.moveTo(part.position.x, part.position.y);\n                                    c.lineTo((part.vertices[0].x + part.vertices[part.vertices.length - 1].x) / 2, (part.vertices[0].y + part.vertices[part.vertices.length - 1].y) / 2);\n                                }\n                            }\n                        }\n                    }\n\n                    if (options.wireframes) {\n                        c.strokeStyle = 'indianred';\n                        c.lineWidth = 1;\n                    } else {\n                        c.strokeStyle = 'rgba(255, 255, 255, 0.4)';\n                        c.globalCompositeOperation = 'overlay';\n                        c.lineWidth = 2;\n                    }\n\n                    c.stroke();\n                    c.globalCompositeOperation = 'source-over';\n                };\n\n                /**\n                 * Draws body positions\n                 * @private\n                 * @method bodyPositions\n                 * @param {render} render\n                 * @param {body[]} bodies\n                 * @param {RenderingContext} context\n                 */\n                Render.bodyPositions = function (render, bodies, context) {\n                    var c = context,\n                        engine = render.engine,\n                        options = render.options,\n                        body,\n                        part,\n                        i,\n                        k;\n\n                    c.beginPath();\n\n                    // render current positions\n                    for (i = 0; i < bodies.length; i++) {\n                        body = bodies[i];\n\n                        if (!body.render.visible) continue;\n\n                        // handle compound parts\n                        for (k = 0; k < body.parts.length; k++) {\n                            part = body.parts[k];\n                            c.arc(part.position.x, part.position.y, 3, 0, 2 * Math.PI, false);\n                            c.closePath();\n                        }\n                    }\n\n                    if (options.wireframes) {\n                        c.fillStyle = 'indianred';\n                    } else {\n                        c.fillStyle = 'rgba(0,0,0,0.5)';\n                    }\n                    c.fill();\n\n                    c.beginPath();\n\n                    // render previous positions\n                    for (i = 0; i < bodies.length; i++) {\n                        body = bodies[i];\n                        if (body.render.visible) {\n                            c.arc(body.positionPrev.x, body.positionPrev.y, 2, 0, 2 * Math.PI, false);\n                            c.closePath();\n                        }\n                    }\n\n                    c.fillStyle = 'rgba(255,165,0,0.8)';\n                    c.fill();\n                };\n\n                /**\n                 * Draws body velocity\n                 * @private\n                 * @method bodyVelocity\n                 * @param {render} render\n                 * @param {body[]} bodies\n                 * @param {RenderingContext} context\n                 */\n                Render.bodyVelocity = function (render, bodies, context) {\n                    var c = context;\n\n                    c.beginPath();\n\n                    for (var i = 0; i < bodies.length; i++) {\n                        var body = bodies[i];\n\n                        if (!body.render.visible) continue;\n\n                        c.moveTo(body.position.x, body.position.y);\n                        c.lineTo(body.position.x + (body.position.x - body.positionPrev.x) * 2, body.position.y + (body.position.y - body.positionPrev.y) * 2);\n                    }\n\n                    c.lineWidth = 3;\n                    c.strokeStyle = 'cornflowerblue';\n                    c.stroke();\n                };\n\n                /**\n                 * Draws body ids\n                 * @private\n                 * @method bodyIds\n                 * @param {render} render\n                 * @param {body[]} bodies\n                 * @param {RenderingContext} context\n                 */\n                Render.bodyIds = function (render, bodies, context) {\n                    var c = context,\n                        i,\n                        j;\n\n                    for (i = 0; i < bodies.length; i++) {\n                        if (!bodies[i].render.visible) continue;\n\n                        var parts = bodies[i].parts;\n                        for (j = parts.length > 1 ? 1 : 0; j < parts.length; j++) {\n                            var part = parts[j];\n                            c.font = \"12px Arial\";\n                            c.fillStyle = 'rgba(255,255,255,0.5)';\n                            c.fillText(part.id, part.position.x + 10, part.position.y - 10);\n                        }\n                    }\n                };\n\n                /**\n                 * Description\n                 * @private\n                 * @method collisions\n                 * @param {render} render\n                 * @param {pair[]} pairs\n                 * @param {RenderingContext} context\n                 */\n                Render.collisions = function (render, pairs, context) {\n                    var c = context,\n                        options = render.options,\n                        pair,\n                        collision,\n                        corrected,\n                        bodyA,\n                        bodyB,\n                        i,\n                        j;\n\n                    c.beginPath();\n\n                    // render collision positions\n                    for (i = 0; i < pairs.length; i++) {\n                        pair = pairs[i];\n\n                        if (!pair.isActive) continue;\n\n                        collision = pair.collision;\n                        for (j = 0; j < pair.activeContacts.length; j++) {\n                            var contact = pair.activeContacts[j],\n                                vertex = contact.vertex;\n                            c.rect(vertex.x - 1.5, vertex.y - 1.5, 3.5, 3.5);\n                        }\n                    }\n\n                    if (options.wireframes) {\n                        c.fillStyle = 'rgba(255,255,255,0.7)';\n                    } else {\n                        c.fillStyle = 'orange';\n                    }\n                    c.fill();\n\n                    c.beginPath();\n\n                    // render collision normals\n                    for (i = 0; i < pairs.length; i++) {\n                        pair = pairs[i];\n\n                        if (!pair.isActive) continue;\n\n                        collision = pair.collision;\n\n                        if (pair.activeContacts.length > 0) {\n                            var normalPosX = pair.activeContacts[0].vertex.x,\n                                normalPosY = pair.activeContacts[0].vertex.y;\n\n                            if (pair.activeContacts.length === 2) {\n                                normalPosX = (pair.activeContacts[0].vertex.x + pair.activeContacts[1].vertex.x) / 2;\n                                normalPosY = (pair.activeContacts[0].vertex.y + pair.activeContacts[1].vertex.y) / 2;\n                            }\n\n                            if (collision.bodyB === collision.supports[0].body || collision.bodyA.isStatic === true) {\n                                c.moveTo(normalPosX - collision.normal.x * 8, normalPosY - collision.normal.y * 8);\n                            } else {\n                                c.moveTo(normalPosX + collision.normal.x * 8, normalPosY + collision.normal.y * 8);\n                            }\n\n                            c.lineTo(normalPosX, normalPosY);\n                        }\n                    }\n\n                    if (options.wireframes) {\n                        c.strokeStyle = 'rgba(255,165,0,0.7)';\n                    } else {\n                        c.strokeStyle = 'orange';\n                    }\n\n                    c.lineWidth = 1;\n                    c.stroke();\n                };\n\n                /**\n                 * Description\n                 * @private\n                 * @method separations\n                 * @param {render} render\n                 * @param {pair[]} pairs\n                 * @param {RenderingContext} context\n                 */\n                Render.separations = function (render, pairs, context) {\n                    var c = context,\n                        options = render.options,\n                        pair,\n                        collision,\n                        corrected,\n                        bodyA,\n                        bodyB,\n                        i,\n                        j;\n\n                    c.beginPath();\n\n                    // render separations\n                    for (i = 0; i < pairs.length; i++) {\n                        pair = pairs[i];\n\n                        if (!pair.isActive) continue;\n\n                        collision = pair.collision;\n                        bodyA = collision.bodyA;\n                        bodyB = collision.bodyB;\n\n                        var k = 1;\n\n                        if (!bodyB.isStatic && !bodyA.isStatic) k = 0.5;\n                        if (bodyB.isStatic) k = 0;\n\n                        c.moveTo(bodyB.position.x, bodyB.position.y);\n                        c.lineTo(bodyB.position.x - collision.penetration.x * k, bodyB.position.y - collision.penetration.y * k);\n\n                        k = 1;\n\n                        if (!bodyB.isStatic && !bodyA.isStatic) k = 0.5;\n                        if (bodyA.isStatic) k = 0;\n\n                        c.moveTo(bodyA.position.x, bodyA.position.y);\n                        c.lineTo(bodyA.position.x + collision.penetration.x * k, bodyA.position.y + collision.penetration.y * k);\n                    }\n\n                    if (options.wireframes) {\n                        c.strokeStyle = 'rgba(255,165,0,0.5)';\n                    } else {\n                        c.strokeStyle = 'orange';\n                    }\n                    c.stroke();\n                };\n\n                /**\n                 * Description\n                 * @private\n                 * @method grid\n                 * @param {render} render\n                 * @param {grid} grid\n                 * @param {RenderingContext} context\n                 */\n                Render.grid = function (render, grid, context) {\n                    var c = context,\n                        options = render.options;\n\n                    if (options.wireframes) {\n                        c.strokeStyle = 'rgba(255,180,0,0.1)';\n                    } else {\n                        c.strokeStyle = 'rgba(255,180,0,0.5)';\n                    }\n\n                    c.beginPath();\n\n                    var bucketKeys = Common.keys(grid.buckets);\n\n                    for (var i = 0; i < bucketKeys.length; i++) {\n                        var bucketId = bucketKeys[i];\n\n                        if (grid.buckets[bucketId].length < 2) continue;\n\n                        var region = bucketId.split(/C|R/);\n                        c.rect(0.5 + parseInt(region[1], 10) * grid.bucketWidth, 0.5 + parseInt(region[2], 10) * grid.bucketHeight, grid.bucketWidth, grid.bucketHeight);\n                    }\n\n                    c.lineWidth = 1;\n                    c.stroke();\n                };\n\n                /**\n                 * Description\n                 * @private\n                 * @method inspector\n                 * @param {inspector} inspector\n                 * @param {RenderingContext} context\n                 */\n                Render.inspector = function (inspector, context) {\n                    var engine = inspector.engine,\n                        selected = inspector.selected,\n                        render = inspector.render,\n                        options = render.options,\n                        bounds;\n\n                    if (options.hasBounds) {\n                        var boundsWidth = render.bounds.max.x - render.bounds.min.x,\n                            boundsHeight = render.bounds.max.y - render.bounds.min.y,\n                            boundsScaleX = boundsWidth / render.options.width,\n                            boundsScaleY = boundsHeight / render.options.height;\n\n                        context.scale(1 / boundsScaleX, 1 / boundsScaleY);\n                        context.translate(-render.bounds.min.x, -render.bounds.min.y);\n                    }\n\n                    for (var i = 0; i < selected.length; i++) {\n                        var item = selected[i].data;\n\n                        context.translate(0.5, 0.5);\n                        context.lineWidth = 1;\n                        context.strokeStyle = 'rgba(255,165,0,0.9)';\n                        context.setLineDash([1, 2]);\n\n                        switch (item.type) {\n\n                            case 'body':\n\n                                // render body selections\n                                bounds = item.bounds;\n                                context.beginPath();\n                                context.rect(Math.floor(bounds.min.x - 3), Math.floor(bounds.min.y - 3), Math.floor(bounds.max.x - bounds.min.x + 6), Math.floor(bounds.max.y - bounds.min.y + 6));\n                                context.closePath();\n                                context.stroke();\n\n                                break;\n\n                            case 'constraint':\n\n                                // render constraint selections\n                                var point = item.pointA;\n                                if (item.bodyA) point = item.pointB;\n                                context.beginPath();\n                                context.arc(point.x, point.y, 10, 0, 2 * Math.PI);\n                                context.closePath();\n                                context.stroke();\n\n                                break;\n\n                        }\n\n                        context.setLineDash([]);\n                        context.translate(-0.5, -0.5);\n                    }\n\n                    // render selection region\n                    if (inspector.selectStart !== null) {\n                        context.translate(0.5, 0.5);\n                        context.lineWidth = 1;\n                        context.strokeStyle = 'rgba(255,165,0,0.6)';\n                        context.fillStyle = 'rgba(255,165,0,0.1)';\n                        bounds = inspector.selectBounds;\n                        context.beginPath();\n                        context.rect(Math.floor(bounds.min.x), Math.floor(bounds.min.y), Math.floor(bounds.max.x - bounds.min.x), Math.floor(bounds.max.y - bounds.min.y));\n                        context.closePath();\n                        context.stroke();\n                        context.fill();\n                        context.translate(-0.5, -0.5);\n                    }\n\n                    if (options.hasBounds) context.setTransform(1, 0, 0, 1, 0, 0);\n                };\n\n                /**\n                 * Description\n                 * @method _createCanvas\n                 * @private\n                 * @param {} width\n                 * @param {} height\n                 * @return canvas\n                 */\n                var _createCanvas = function _createCanvas(width, height) {\n                    var canvas = document.createElement('canvas');\n                    canvas.width = width;\n                    canvas.height = height;\n                    canvas.oncontextmenu = function () {\n                        return false;\n                    };\n                    canvas.onselectstart = function () {\n                        return false;\n                    };\n                    return canvas;\n                };\n\n                /**\n                 * Gets the pixel ratio of the canvas.\n                 * @method _getPixelRatio\n                 * @private\n                 * @param {HTMLElement} canvas\n                 * @return {Number} pixel ratio\n                 */\n                var _getPixelRatio = function _getPixelRatio(canvas) {\n                    var context = canvas.getContext('2d'),\n                        devicePixelRatio = window.devicePixelRatio || 1,\n                        backingStorePixelRatio = context.webkitBackingStorePixelRatio || context.mozBackingStorePixelRatio || context.msBackingStorePixelRatio || context.oBackingStorePixelRatio || context.backingStorePixelRatio || 1;\n\n                    return devicePixelRatio / backingStorePixelRatio;\n                };\n\n                /**\n                 * Gets the requested texture (an Image) via its path\n                 * @method _getTexture\n                 * @private\n                 * @param {render} render\n                 * @param {string} imagePath\n                 * @return {Image} texture\n                 */\n                var _getTexture = function _getTexture(render, imagePath) {\n                    var image = render.textures[imagePath];\n\n                    if (image) return image;\n\n                    image = render.textures[imagePath] = new Image();\n                    image.src = imagePath;\n\n                    return image;\n                };\n\n                /**\n                 * Applies the background to the canvas using CSS.\n                 * @method applyBackground\n                 * @private\n                 * @param {render} render\n                 * @param {string} background\n                 */\n                var _applyBackground = function _applyBackground(render, background) {\n                    var cssBackground = background;\n\n                    if (/(jpg|gif|png)$/.test(background)) cssBackground = 'url(' + background + ')';\n\n                    render.canvas.style.background = cssBackground;\n                    render.canvas.style.backgroundSize = \"contain\";\n                    render.currentBackground = background;\n                };\n\n                /*\n                *\n                *  Events Documentation\n                *\n                */\n\n                /**\n                * Fired before rendering\n                *\n                * @event beforeRender\n                * @param {} event An event object\n                * @param {number} event.timestamp The engine.timing.timestamp of the event\n                * @param {} event.source The source object of the event\n                * @param {} event.name The name of the event\n                */\n\n                /**\n                * Fired after rendering\n                *\n                * @event afterRender\n                * @param {} event An event object\n                * @param {number} event.timestamp The engine.timing.timestamp of the event\n                * @param {} event.source The source object of the event\n                * @param {} event.name The name of the event\n                */\n\n                /*\n                *\n                *  Properties Documentation\n                *\n                */\n\n                /**\n                 * A back-reference to the `Matter.Render` module.\n                 *\n                 * @property controller\n                 * @type render\n                 */\n\n                /**\n                 * A reference to the `Matter.Engine` instance to be used.\n                 *\n                 * @property engine\n                 * @type engine\n                 */\n\n                /**\n                 * A reference to the element where the canvas is to be inserted (if `render.canvas` has not been specified)\n                 *\n                 * @property element\n                 * @type HTMLElement\n                 * @default null\n                 */\n\n                /**\n                 * The canvas element to render to. If not specified, one will be created if `render.element` has been specified.\n                 *\n                 * @property canvas\n                 * @type HTMLCanvasElement\n                 * @default null\n                 */\n\n                /**\n                 * The configuration options of the renderer.\n                 *\n                 * @property options\n                 * @type {}\n                 */\n\n                /**\n                 * The target width in pixels of the `render.canvas` to be created.\n                 *\n                 * @property options.width\n                 * @type number\n                 * @default 800\n                 */\n\n                /**\n                 * The target height in pixels of the `render.canvas` to be created.\n                 *\n                 * @property options.height\n                 * @type number\n                 * @default 600\n                 */\n\n                /**\n                 * A flag that specifies if `render.bounds` should be used when rendering.\n                 *\n                 * @property options.hasBounds\n                 * @type boolean\n                 * @default false\n                 */\n\n                /**\n                 * A `Bounds` object that specifies the drawing view region.\n                 * Rendering will be automatically transformed and scaled to fit within the canvas size (`render.options.width` and `render.options.height`).\n                 * This allows for creating views that can pan or zoom around the scene.\n                 * You must also set `render.options.hasBounds` to `true` to enable bounded rendering.\n                 *\n                 * @property bounds\n                 * @type bounds\n                 */\n\n                /**\n                 * The 2d rendering context from the `render.canvas` element.\n                 *\n                 * @property context\n                 * @type CanvasRenderingContext2D\n                 */\n\n                /**\n                 * The sprite texture cache.\n                 *\n                 * @property textures\n                 * @type {}\n                 */\n            })();\n        }, { \"../body/Composite\": 2, \"../collision/Grid\": 6, \"../core/Common\": 14, \"../core/Events\": 16, \"../core/Mouse\": 19, \"../geometry/Bounds\": 26, \"../geometry/Vector\": 28 }], 32: [function (_dereq_, module, exports) {\n            /**\n            * The `Matter.RenderPixi` module is an example renderer using pixi.js.\n            * See also `Matter.Render` for a canvas based renderer.\n            *\n            * @class RenderPixi\n            * @deprecated the Matter.RenderPixi module will soon be removed from the Matter.js core.\n            * It will likely be moved to its own repository (but maintenance will be limited).\n            */\n\n            var RenderPixi = {};\n\n            module.exports = RenderPixi;\n\n            var Bounds = _dereq_('../geometry/Bounds');\n            var Composite = _dereq_('../body/Composite');\n            var Common = _dereq_('../core/Common');\n            var Events = _dereq_('../core/Events');\n            var Vector = _dereq_('../geometry/Vector');\n\n            (function () {\n\n                var _requestAnimationFrame, _cancelAnimationFrame;\n\n                if (typeof window !== 'undefined') {\n                    _requestAnimationFrame = window.requestAnimationFrame || window.webkitRequestAnimationFrame || window.mozRequestAnimationFrame || window.msRequestAnimationFrame || function (callback) {\n                        window.setTimeout(function () {\n                            callback(Common.now());\n                        }, 1000 / 60);\n                    };\n\n                    _cancelAnimationFrame = window.cancelAnimationFrame || window.mozCancelAnimationFrame || window.webkitCancelAnimationFrame || window.msCancelAnimationFrame;\n                }\n\n                /**\n                 * Creates a new Pixi.js WebGL renderer\n                 * @method create\n                 * @param {object} options\n                 * @return {RenderPixi} A new renderer\n                 * @deprecated\n                 */\n                RenderPixi.create = function (options) {\n                    Common.warn('RenderPixi.create: Matter.RenderPixi is deprecated (see docs)');\n\n                    var defaults = {\n                        controller: RenderPixi,\n                        engine: null,\n                        element: null,\n                        frameRequestId: null,\n                        canvas: null,\n                        renderer: null,\n                        container: null,\n                        spriteContainer: null,\n                        pixiOptions: null,\n                        options: {\n                            width: 800,\n                            height: 600,\n                            background: '#fafafa',\n                            wireframeBackground: '#222',\n                            hasBounds: false,\n                            enabled: true,\n                            wireframes: true,\n                            showSleeping: true,\n                            showDebug: false,\n                            showBroadphase: false,\n                            showBounds: false,\n                            showVelocity: false,\n                            showCollisions: false,\n                            showAxes: false,\n                            showPositions: false,\n                            showAngleIndicator: false,\n                            showIds: false,\n                            showShadows: false\n                        }\n                    };\n\n                    var render = Common.extend(defaults, options),\n                        transparent = !render.options.wireframes && render.options.background === 'transparent';\n\n                    // init pixi\n                    render.pixiOptions = render.pixiOptions || {\n                        view: render.canvas,\n                        transparent: transparent,\n                        antialias: true,\n                        backgroundColor: options.background\n                    };\n\n                    render.mouse = options.mouse;\n                    render.engine = options.engine;\n                    render.renderer = render.renderer || new PIXI.WebGLRenderer(render.options.width, render.options.height, render.pixiOptions);\n                    render.container = render.container || new PIXI.Container();\n                    render.spriteContainer = render.spriteContainer || new PIXI.Container();\n                    render.canvas = render.canvas || render.renderer.view;\n                    render.bounds = render.bounds || {\n                        min: {\n                            x: 0,\n                            y: 0\n                        },\n                        max: {\n                            x: render.options.width,\n                            y: render.options.height\n                        }\n                    };\n\n                    // event listeners\n                    Events.on(render.engine, 'beforeUpdate', function () {\n                        RenderPixi.clear(render);\n                    });\n\n                    // caches\n                    render.textures = {};\n                    render.sprites = {};\n                    render.primitives = {};\n\n                    // use a sprite batch for performance\n                    render.container.addChild(render.spriteContainer);\n\n                    // insert canvas\n                    if (Common.isElement(render.element)) {\n                        render.element.appendChild(render.canvas);\n                    } else {\n                        Common.warn('No \"render.element\" passed, \"render.canvas\" was not inserted into document.');\n                    }\n\n                    // prevent menus on canvas\n                    render.canvas.oncontextmenu = function () {\n                        return false;\n                    };\n                    render.canvas.onselectstart = function () {\n                        return false;\n                    };\n\n                    return render;\n                };\n\n                /**\n                 * Continuously updates the render canvas on the `requestAnimationFrame` event.\n                 * @method run\n                 * @param {render} render\n                 * @deprecated\n                 */\n                RenderPixi.run = function (render) {\n                    (function loop(time) {\n                        render.frameRequestId = _requestAnimationFrame(loop);\n                        RenderPixi.world(render);\n                    })();\n                };\n\n                /**\n                 * Ends execution of `Render.run` on the given `render`, by canceling the animation frame request event loop.\n                 * @method stop\n                 * @param {render} render\n                 * @deprecated\n                 */\n                RenderPixi.stop = function (render) {\n                    _cancelAnimationFrame(render.frameRequestId);\n                };\n\n                /**\n                 * Clears the scene graph\n                 * @method clear\n                 * @param {RenderPixi} render\n                 * @deprecated\n                 */\n                RenderPixi.clear = function (render) {\n                    var container = render.container,\n                        spriteContainer = render.spriteContainer;\n\n                    // clear stage container\n                    while (container.children[0]) {\n                        container.removeChild(container.children[0]);\n                    }\n\n                    // clear sprite batch\n                    while (spriteContainer.children[0]) {\n                        spriteContainer.removeChild(spriteContainer.children[0]);\n                    }\n\n                    var bgSprite = render.sprites['bg-0'];\n\n                    // clear caches\n                    render.textures = {};\n                    render.sprites = {};\n                    render.primitives = {};\n\n                    // set background sprite\n                    render.sprites['bg-0'] = bgSprite;\n                    if (bgSprite) container.addChildAt(bgSprite, 0);\n\n                    // add sprite batch back into container\n                    render.container.addChild(render.spriteContainer);\n\n                    // reset background state\n                    render.currentBackground = null;\n\n                    // reset bounds transforms\n                    container.scale.set(1, 1);\n                    container.position.set(0, 0);\n                };\n\n                /**\n                 * Sets the background of the canvas \n                 * @method setBackground\n                 * @param {RenderPixi} render\n                 * @param {string} background\n                 * @deprecated\n                 */\n                RenderPixi.setBackground = function (render, background) {\n                    if (render.currentBackground !== background) {\n                        var isColor = background.indexOf && background.indexOf('#') !== -1,\n                            bgSprite = render.sprites['bg-0'];\n\n                        if (isColor) {\n                            // if solid background color\n                            var color = Common.colorToNumber(background);\n                            render.renderer.backgroundColor = color;\n\n                            // remove background sprite if existing\n                            if (bgSprite) render.container.removeChild(bgSprite);\n                        } else {\n                            // initialise background sprite if needed\n                            if (!bgSprite) {\n                                var texture = _getTexture(render, background);\n\n                                bgSprite = render.sprites['bg-0'] = new PIXI.Sprite(texture);\n                                bgSprite.position.x = 0;\n                                bgSprite.position.y = 0;\n                                render.container.addChildAt(bgSprite, 0);\n                            }\n                        }\n\n                        render.currentBackground = background;\n                    }\n                };\n\n                /**\n                 * Description\n                 * @method world\n                 * @param {engine} engine\n                 * @deprecated\n                 */\n                RenderPixi.world = function (render) {\n                    var engine = render.engine,\n                        world = engine.world,\n                        renderer = render.renderer,\n                        container = render.container,\n                        options = render.options,\n                        bodies = Composite.allBodies(world),\n                        allConstraints = Composite.allConstraints(world),\n                        constraints = [],\n                        i;\n\n                    if (options.wireframes) {\n                        RenderPixi.setBackground(render, options.wireframeBackground);\n                    } else {\n                        RenderPixi.setBackground(render, options.background);\n                    }\n\n                    // handle bounds\n                    var boundsWidth = render.bounds.max.x - render.bounds.min.x,\n                        boundsHeight = render.bounds.max.y - render.bounds.min.y,\n                        boundsScaleX = boundsWidth / render.options.width,\n                        boundsScaleY = boundsHeight / render.options.height;\n\n                    if (options.hasBounds) {\n                        // Hide bodies that are not in view\n                        for (i = 0; i < bodies.length; i++) {\n                            var body = bodies[i];\n                            body.render.sprite.visible = Bounds.overlaps(body.bounds, render.bounds);\n                        }\n\n                        // filter out constraints that are not in view\n                        for (i = 0; i < allConstraints.length; i++) {\n                            var constraint = allConstraints[i],\n                                bodyA = constraint.bodyA,\n                                bodyB = constraint.bodyB,\n                                pointAWorld = constraint.pointA,\n                                pointBWorld = constraint.pointB;\n\n                            if (bodyA) pointAWorld = Vector.add(bodyA.position, constraint.pointA);\n                            if (bodyB) pointBWorld = Vector.add(bodyB.position, constraint.pointB);\n\n                            if (!pointAWorld || !pointBWorld) continue;\n\n                            if (Bounds.contains(render.bounds, pointAWorld) || Bounds.contains(render.bounds, pointBWorld)) constraints.push(constraint);\n                        }\n\n                        // transform the view\n                        container.scale.set(1 / boundsScaleX, 1 / boundsScaleY);\n                        container.position.set(-render.bounds.min.x * (1 / boundsScaleX), -render.bounds.min.y * (1 / boundsScaleY));\n                    } else {\n                        constraints = allConstraints;\n                    }\n\n                    for (i = 0; i < bodies.length; i++) {\n                        RenderPixi.body(render, bodies[i]);\n                    }for (i = 0; i < constraints.length; i++) {\n                        RenderPixi.constraint(render, constraints[i]);\n                    }renderer.render(container);\n                };\n\n                /**\n                 * Description\n                 * @method constraint\n                 * @param {engine} engine\n                 * @param {constraint} constraint\n                 * @deprecated\n                 */\n                RenderPixi.constraint = function (render, constraint) {\n                    var engine = render.engine,\n                        bodyA = constraint.bodyA,\n                        bodyB = constraint.bodyB,\n                        pointA = constraint.pointA,\n                        pointB = constraint.pointB,\n                        container = render.container,\n                        constraintRender = constraint.render,\n                        primitiveId = 'c-' + constraint.id,\n                        primitive = render.primitives[primitiveId];\n\n                    // initialise constraint primitive if not existing\n                    if (!primitive) primitive = render.primitives[primitiveId] = new PIXI.Graphics();\n\n                    // don't render if constraint does not have two end points\n                    if (!constraintRender.visible || !constraint.pointA || !constraint.pointB) {\n                        primitive.clear();\n                        return;\n                    }\n\n                    // add to scene graph if not already there\n                    if (Common.indexOf(container.children, primitive) === -1) container.addChild(primitive);\n\n                    // render the constraint on every update, since they can change dynamically\n                    primitive.clear();\n                    primitive.beginFill(0, 0);\n                    primitive.lineStyle(constraintRender.lineWidth, Common.colorToNumber(constraintRender.strokeStyle), 1);\n\n                    if (bodyA) {\n                        primitive.moveTo(bodyA.position.x + pointA.x, bodyA.position.y + pointA.y);\n                    } else {\n                        primitive.moveTo(pointA.x, pointA.y);\n                    }\n\n                    if (bodyB) {\n                        primitive.lineTo(bodyB.position.x + pointB.x, bodyB.position.y + pointB.y);\n                    } else {\n                        primitive.lineTo(pointB.x, pointB.y);\n                    }\n\n                    primitive.endFill();\n                };\n\n                /**\n                 * Description\n                 * @method body\n                 * @param {engine} engine\n                 * @param {body} body\n                 * @deprecated\n                 */\n                RenderPixi.body = function (render, body) {\n                    var engine = render.engine,\n                        bodyRender = body.render;\n\n                    if (!bodyRender.visible) return;\n\n                    if (bodyRender.sprite && bodyRender.sprite.texture) {\n                        var spriteId = 'b-' + body.id,\n                            sprite = render.sprites[spriteId],\n                            spriteContainer = render.spriteContainer;\n\n                        // initialise body sprite if not existing\n                        if (!sprite) sprite = render.sprites[spriteId] = _createBodySprite(render, body);\n\n                        // add to scene graph if not already there\n                        if (Common.indexOf(spriteContainer.children, sprite) === -1) spriteContainer.addChild(sprite);\n\n                        // update body sprite\n                        sprite.position.x = body.position.x;\n                        sprite.position.y = body.position.y;\n                        sprite.rotation = body.angle;\n                        sprite.scale.x = bodyRender.sprite.xScale || 1;\n                        sprite.scale.y = bodyRender.sprite.yScale || 1;\n                    } else {\n                        var primitiveId = 'b-' + body.id,\n                            primitive = render.primitives[primitiveId],\n                            container = render.container;\n\n                        // initialise body primitive if not existing\n                        if (!primitive) {\n                            primitive = render.primitives[primitiveId] = _createBodyPrimitive(render, body);\n                            primitive.initialAngle = body.angle;\n                        }\n\n                        // add to scene graph if not already there\n                        if (Common.indexOf(container.children, primitive) === -1) container.addChild(primitive);\n\n                        // update body primitive\n                        primitive.position.x = body.position.x;\n                        primitive.position.y = body.position.y;\n                        primitive.rotation = body.angle - primitive.initialAngle;\n                    }\n                };\n\n                /**\n                 * Creates a body sprite\n                 * @method _createBodySprite\n                 * @private\n                 * @param {RenderPixi} render\n                 * @param {body} body\n                 * @return {PIXI.Sprite} sprite\n                 * @deprecated\n                 */\n                var _createBodySprite = function _createBodySprite(render, body) {\n                    var bodyRender = body.render,\n                        texturePath = bodyRender.sprite.texture,\n                        texture = _getTexture(render, texturePath),\n                        sprite = new PIXI.Sprite(texture);\n\n                    sprite.anchor.x = body.render.sprite.xOffset;\n                    sprite.anchor.y = body.render.sprite.yOffset;\n\n                    return sprite;\n                };\n\n                /**\n                 * Creates a body primitive\n                 * @method _createBodyPrimitive\n                 * @private\n                 * @param {RenderPixi} render\n                 * @param {body} body\n                 * @return {PIXI.Graphics} graphics\n                 * @deprecated\n                 */\n                var _createBodyPrimitive = function _createBodyPrimitive(render, body) {\n                    var bodyRender = body.render,\n                        options = render.options,\n                        primitive = new PIXI.Graphics(),\n                        fillStyle = Common.colorToNumber(bodyRender.fillStyle),\n                        strokeStyle = Common.colorToNumber(bodyRender.strokeStyle),\n                        strokeStyleIndicator = Common.colorToNumber(bodyRender.strokeStyle),\n                        strokeStyleWireframe = Common.colorToNumber('#bbb'),\n                        strokeStyleWireframeIndicator = Common.colorToNumber('#CD5C5C'),\n                        part;\n\n                    primitive.clear();\n\n                    // handle compound parts\n                    for (var k = body.parts.length > 1 ? 1 : 0; k < body.parts.length; k++) {\n                        part = body.parts[k];\n\n                        if (!options.wireframes) {\n                            primitive.beginFill(fillStyle, 1);\n                            primitive.lineStyle(bodyRender.lineWidth, strokeStyle, 1);\n                        } else {\n                            primitive.beginFill(0, 0);\n                            primitive.lineStyle(1, strokeStyleWireframe, 1);\n                        }\n\n                        primitive.moveTo(part.vertices[0].x - body.position.x, part.vertices[0].y - body.position.y);\n\n                        for (var j = 1; j < part.vertices.length; j++) {\n                            primitive.lineTo(part.vertices[j].x - body.position.x, part.vertices[j].y - body.position.y);\n                        }\n\n                        primitive.lineTo(part.vertices[0].x - body.position.x, part.vertices[0].y - body.position.y);\n\n                        primitive.endFill();\n\n                        // angle indicator\n                        if (options.showAngleIndicator || options.showAxes) {\n                            primitive.beginFill(0, 0);\n\n                            if (options.wireframes) {\n                                primitive.lineStyle(1, strokeStyleWireframeIndicator, 1);\n                            } else {\n                                primitive.lineStyle(1, strokeStyleIndicator);\n                            }\n\n                            primitive.moveTo(part.position.x - body.position.x, part.position.y - body.position.y);\n                            primitive.lineTo((part.vertices[0].x + part.vertices[part.vertices.length - 1].x) / 2 - body.position.x, (part.vertices[0].y + part.vertices[part.vertices.length - 1].y) / 2 - body.position.y);\n\n                            primitive.endFill();\n                        }\n                    }\n\n                    return primitive;\n                };\n\n                /**\n                 * Gets the requested texture (a PIXI.Texture) via its path\n                 * @method _getTexture\n                 * @private\n                 * @param {RenderPixi} render\n                 * @param {string} imagePath\n                 * @return {PIXI.Texture} texture\n                 * @deprecated\n                 */\n                var _getTexture = function _getTexture(render, imagePath) {\n                    var texture = render.textures[imagePath];\n\n                    if (!texture) texture = render.textures[imagePath] = PIXI.Texture.fromImage(imagePath);\n\n                    return texture;\n                };\n            })();\n        }, { \"../body/Composite\": 2, \"../core/Common\": 14, \"../core/Events\": 16, \"../geometry/Bounds\": 26, \"../geometry/Vector\": 28 }] }, {}, [30])(30);\n});\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(1)))\n\n/***/ }),\n/* 28 */\n/***/ (function(module, exports) {\n\n// removed by extract-text-webpack-plugin\nmodule.exports = {\"trash\":\"dh-dh-plastic-counter-trash\",\"trash__fallback\":\"dh-dh-plastic-counter-trash__fallback\",\"trash--active\":\"dh-dh-plastic-counter-trash--active\",\"trash__fallback-top\":\"dh-dh-plastic-counter-trash__fallback-top\",\"trash__fallback-body\":\"dh-dh-plastic-counter-trash__fallback-body\"};\n\n/***/ }),\n/* 29 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.Sea = undefined;\n\nvar _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();\n\nvar _preact = __webpack_require__(0);\n\nvar _Sea = __webpack_require__(30);\n\nvar _Sea2 = _interopRequireDefault(_Sea);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return call && (typeof call === \"object\" || typeof call === \"function\") ? call : self; }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function, not \" + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } //  @jsx h\n\nvar Sea = exports.Sea = function (_Component) {\n  _inherits(Sea, _Component);\n\n  function Sea() {\n    _classCallCheck(this, Sea);\n\n    return _possibleConstructorReturn(this, (Sea.__proto__ || Object.getPrototypeOf(Sea)).apply(this, arguments));\n  }\n\n  _createClass(Sea, [{\n    key: 'shouldComponentUpdate',\n    value: function shouldComponentUpdate() {\n      return false;\n    }\n  }, {\n    key: 'render',\n    value: function render() {\n      return (0, _preact.h)(\n        'div',\n        { 'class': _Sea2.default.sea },\n        (0, _preact.h)('div', { 'class': _Sea2.default.sea__waves })\n      );\n    }\n  }]);\n\n  return Sea;\n}(_preact.Component);\n\n/***/ }),\n/* 30 */\n/***/ (function(module, exports) {\n\n// removed by extract-text-webpack-plugin\nmodule.exports = {\"sea\":\"dh-dh-plastic-counter-sea\",\"sea__waves\":\"dh-dh-plastic-counter-sea__waves\",\"app--small\":\"dh-dh-plastic-counter-app--small\",\"app--medium\":\"dh-dh-plastic-counter-app--medium\",\"app--large\":\"dh-dh-plastic-counter-app--large\",\"app--extra-large\":\"dh-dh-plastic-counter-app--extra-large\",\"app--has-intersected\":\"dh-dh-plastic-counter-app--has-intersected\",\"move\":\"dh-dh-plastic-counter-move\",\"sea__flowers\":\"dh-dh-plastic-counter-sea__flowers\"};\n\n/***/ }),\n/* 31 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.SeaOverlay = undefined;\n\nvar _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();\n\nvar _preact = __webpack_require__(0);\n\nvar _SeaOverlay = __webpack_require__(32);\n\nvar _SeaOverlay2 = _interopRequireDefault(_SeaOverlay);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return call && (typeof call === \"object\" || typeof call === \"function\") ? call : self; }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function, not \" + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } //  @jsx h\n\nvar SeaOverlay = exports.SeaOverlay = function (_Component) {\n  _inherits(SeaOverlay, _Component);\n\n  function SeaOverlay() {\n    _classCallCheck(this, SeaOverlay);\n\n    return _possibleConstructorReturn(this, (SeaOverlay.__proto__ || Object.getPrototypeOf(SeaOverlay)).apply(this, arguments));\n  }\n\n  _createClass(SeaOverlay, [{\n    key: 'shouldComponentUpdate',\n    value: function shouldComponentUpdate() {\n      return false;\n    }\n  }, {\n    key: 'render',\n    value: function render() {\n      return (0, _preact.h)('div', { 'class': _SeaOverlay2.default['sea-overlay'] });\n    }\n  }]);\n\n  return SeaOverlay;\n}(_preact.Component);\n\n/***/ }),\n/* 32 */\n/***/ (function(module, exports) {\n\n// removed by extract-text-webpack-plugin\nmodule.exports = {\"sea-overlay\":\"dh-dh-plastic-counter-sea-overlay\"};\n\n/***/ }),\n/* 33 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.SeaLight = undefined;\n\nvar _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();\n\nvar _preact = __webpack_require__(0);\n\nvar _SeaLight = __webpack_require__(34);\n\nvar _SeaLight2 = _interopRequireDefault(_SeaLight);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return call && (typeof call === \"object\" || typeof call === \"function\") ? call : self; }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function, not \" + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } //  @jsx h\n\nvar SeaLight = exports.SeaLight = function (_Component) {\n  _inherits(SeaLight, _Component);\n\n  function SeaLight() {\n    _classCallCheck(this, SeaLight);\n\n    return _possibleConstructorReturn(this, (SeaLight.__proto__ || Object.getPrototypeOf(SeaLight)).apply(this, arguments));\n  }\n\n  _createClass(SeaLight, [{\n    key: 'shouldComponentUpdate',\n    value: function shouldComponentUpdate() {\n      return false;\n    }\n  }, {\n    key: 'render',\n    value: function render() {\n      return (0, _preact.h)('div', { 'class': _SeaLight2.default['sea-light'] });\n    }\n  }]);\n\n  return SeaLight;\n}(_preact.Component);\n\n/***/ }),\n/* 34 */\n/***/ (function(module, exports) {\n\n// removed by extract-text-webpack-plugin\nmodule.exports = {\"sea-light\":\"dh-dh-plastic-counter-sea-light\"};\n\n/***/ }),\n/* 35 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\nvar __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;\n\nvar _typeof = typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; };\n\n!function (e, n) {\n  \"object\" == ( false ? \"undefined\" : _typeof(exports)) && \"undefined\" != typeof module ? n(exports) :  true ? !(__WEBPACK_AMD_DEFINE_ARRAY__ = [exports], __WEBPACK_AMD_DEFINE_FACTORY__ = (n),\n\t\t\t\t__WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ?\n\t\t\t\t(__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__),\n\t\t\t\t__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)) : n(e[\"dh-analytics-utils\"] = {});\n}(undefined, function (e) {\n  \"use strict\";\n  function n() {\n    return window.ga;\n  }var t = Object.assign || function (e) {\n    for (var n = 1; n < arguments.length; n++) {\n      var t = arguments[n];for (var o in t) {\n        Object.prototype.hasOwnProperty.call(t, o) && (e[o] = t[o]);\n      }\n    }return e;\n  };e.createGoogleAnalyticsTracker = function (e) {\n    var o = [],\n        r = e.name,\n        a = e.gaPropertyId,\n        i = e.self,\n        l = e.context;if (!(r && a && i && l)) throw new Error(\"Unable to create google analytics tracker. Please pass an object containing name, gaPropertyId, self and context to createGoogleAnalyticsTracker method\");var c,\n        s,\n        d,\n        u,\n        f,\n        g,\n        p,\n        y,\n        w = (c = i.id, s = l.id, d = i.title, u = i.publishedDate, f = c === s, g = document.referrer, { dimension1: c ? \"pp:\" + c : null, dimension2: d || null, dimension3: u ? String(u.getFullYear()) : null, dimension4: u ? String(u.getMonth() + 1) : null, dimension5: u ? String(u.getDate()) : null, dimension6: g.replace(/^(https?:\\/\\/)?www./, \"$1\"), dimension7: g.replace(/^(https?:\\/\\/)/, \"\").replace(/^www./, \"\"), dimension10: f ? null : s ? \"pp:\" + s : null }),\n        v = (p = o, y = !1, function (e, o, r, a, i) {\n      if (!r.category || !r.action) throw new Error(\"Error sending event to google analytics: Event is missing mandatory fields category and/or action\");n() ? (y || (function (e, n) {\n        window.ga(\"create\", { trackingId: n, cookieDomain: \"auto\", name: e }), window.ga(e + \".set\", \"anonymizeIp\", !0);\n      }(e, o), y = !0), window.ga(e + \".send\", \"event\", function (e, n) {\n        var o = {};e.hasOwnProperty(\"category\") && (o.eventCategory = e.category), e.hasOwnProperty(\"action\") && (o.eventAction = e.action), e.hasOwnProperty(\"label\") && (o.eventLabel = e.label), e.hasOwnProperty(\"value\") && (o.eventValue = e.value), o.nonInteraction = e.nonInteraction || !1;var r = t({}, n, e.fieldsObject);return t({}, o, r);\n      }(r, a))) : p.push(r);\n    }),\n        m = setInterval(function () {\n      if (n()) for (clearInterval(m); o.length;) {\n        var e = o.shift();v(r, a, e, w);\n      }\n    }, 1e3);return { sendEvent: function sendEvent(e) {\n        v(r, a, e, w);\n      } };\n  }, Object.defineProperty(e, \"__esModule\", { value: !0 });\n});\n\n/***/ }),\n/* 36 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.getContextId = getContextId;\nvar POLOPOLY_ID_REGEX = /[1-9]{1,2}\\.\\d+/g;\n\nfunction getContextId(url) {\n  return extractPolopolyIdFromString(url);\n}\n\nfunction extractPolopolyIdFromString(str) {\n  var matches = str.match(POLOPOLY_ID_REGEX);\n  if (matches && matches.length) {\n    return matches[0];\n  }\n  return null;\n}\n\n/***/ })\n/******/ ]);\n\n\n// WEBPACK FOOTER //\n// v1-bundle-b13343bf5e67236e0fb7.js"," \t// The module cache\n \tvar installedModules = {};\n\n \t// The require function\n \tfunction __webpack_require__(moduleId) {\n\n \t\t// Check if module is in cache\n \t\tif(installedModules[moduleId]) {\n \t\t\treturn installedModules[moduleId].exports;\n \t\t}\n \t\t// Create a new module (and put it into the cache)\n \t\tvar module = installedModules[moduleId] = {\n \t\t\ti: moduleId,\n \t\t\tl: false,\n \t\t\texports: {}\n \t\t};\n\n \t\t// Execute the module function\n \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n \t\t// Flag the module as loaded\n \t\tmodule.l = true;\n\n \t\t// Return the exports of the module\n \t\treturn module.exports;\n \t}\n\n\n \t// expose the modules object (__webpack_modules__)\n \t__webpack_require__.m = modules;\n\n \t// expose the module cache\n \t__webpack_require__.c = installedModules;\n\n \t// define getter function for harmony exports\n \t__webpack_require__.d = function(exports, name, getter) {\n \t\tif(!__webpack_require__.o(exports, name)) {\n \t\t\tObject.defineProperty(exports, name, {\n \t\t\t\tconfigurable: false,\n \t\t\t\tenumerable: true,\n \t\t\t\tget: getter\n \t\t\t});\n \t\t}\n \t};\n\n \t// getDefaultExport function for compatibility with non-harmony modules\n \t__webpack_require__.n = function(module) {\n \t\tvar getter = module && module.__esModule ?\n \t\t\tfunction getDefault() { return module['default']; } :\n \t\t\tfunction getModuleExports() { return module; };\n \t\t__webpack_require__.d(getter, 'a', getter);\n \t\treturn getter;\n \t};\n\n \t// Object.prototype.hasOwnProperty.call\n \t__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };\n\n \t// __webpack_public_path__\n \t__webpack_require__.p = \"https://static.nrk.no/dh/dh-plastic-counter/static/\";\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(__webpack_require__.s = 5);\n\n\n\n// WEBPACK FOOTER //\n// webpack/bootstrap 9b8f6a2e7ac748840ade","/** Virtual DOM Node */\nfunction VNode() {}\n\n/** Global options\n *\t@public\n *\t@namespace options {Object}\n */\nvar options = {\n\n\t/** If `true`, `prop` changes trigger synchronous component updates.\n  *\t@name syncComponentUpdates\n  *\t@type Boolean\n  *\t@default true\n  */\n\t//syncComponentUpdates: true,\n\n\t/** Processes all created VNodes.\n  *\t@param {VNode} vnode\tA newly-created VNode to normalize/process\n  */\n\t//vnode(vnode) { }\n\n\t/** Hook invoked after a component is mounted. */\n\t// afterMount(component) { }\n\n\t/** Hook invoked after the DOM is updated with a component's latest render. */\n\t// afterUpdate(component) { }\n\n\t/** Hook invoked immediately before a component is unmounted. */\n\t// beforeUnmount(component) { }\n};\n\nvar stack = [];\n\nvar EMPTY_CHILDREN = [];\n\n/**\n * JSX/hyperscript reviver.\n * @see http://jasonformat.com/wtf-is-jsx\n * Benchmarks: https://esbench.com/bench/57ee8f8e330ab09900a1a1a0\n *\n * Note: this is exported as both `h()` and `createElement()` for compatibility reasons.\n *\n * Creates a VNode (virtual DOM element). A tree of VNodes can be used as a lightweight representation\n * of the structure of a DOM tree. This structure can be realized by recursively comparing it against\n * the current _actual_ DOM structure, and applying only the differences.\n *\n * `h()`/`createElement()` accepts an element name, a list of attributes/props,\n * and optionally children to append to the element.\n *\n * @example The following DOM tree\n *\n * `<div id=\"foo\" name=\"bar\">Hello!</div>`\n *\n * can be constructed using this function as:\n *\n * `h('div', { id: 'foo', name : 'bar' }, 'Hello!');`\n *\n * @param {string} nodeName\tAn element name. Ex: `div`, `a`, `span`, etc.\n * @param {Object} attributes\tAny attributes/props to set on the created element.\n * @param rest\t\t\tAdditional arguments are taken to be children to append. Can be infinitely nested Arrays.\n *\n * @public\n */\nfunction h(nodeName, attributes) {\n\tvar children = EMPTY_CHILDREN,\n\t    lastSimple,\n\t    child,\n\t    simple,\n\t    i;\n\tfor (i = arguments.length; i-- > 2;) {\n\t\tstack.push(arguments[i]);\n\t}\n\tif (attributes && attributes.children != null) {\n\t\tif (!stack.length) stack.push(attributes.children);\n\t\tdelete attributes.children;\n\t}\n\twhile (stack.length) {\n\t\tif ((child = stack.pop()) && child.pop !== undefined) {\n\t\t\tfor (i = child.length; i--;) {\n\t\t\t\tstack.push(child[i]);\n\t\t\t}\n\t\t} else {\n\t\t\tif (typeof child === 'boolean') child = null;\n\n\t\t\tif (simple = typeof nodeName !== 'function') {\n\t\t\t\tif (child == null) child = '';else if (typeof child === 'number') child = String(child);else if (typeof child !== 'string') simple = false;\n\t\t\t}\n\n\t\t\tif (simple && lastSimple) {\n\t\t\t\tchildren[children.length - 1] += child;\n\t\t\t} else if (children === EMPTY_CHILDREN) {\n\t\t\t\tchildren = [child];\n\t\t\t} else {\n\t\t\t\tchildren.push(child);\n\t\t\t}\n\n\t\t\tlastSimple = simple;\n\t\t}\n\t}\n\n\tvar p = new VNode();\n\tp.nodeName = nodeName;\n\tp.children = children;\n\tp.attributes = attributes == null ? undefined : attributes;\n\tp.key = attributes == null ? undefined : attributes.key;\n\n\t// if a \"vnode hook\" is defined, pass every created VNode to it\n\tif (options.vnode !== undefined) options.vnode(p);\n\n\treturn p;\n}\n\n/**\n *  Copy all properties from `props` onto `obj`.\n *  @param {Object} obj\t\tObject onto which properties should be copied.\n *  @param {Object} props\tObject from which to copy properties.\n *  @returns obj\n *  @private\n */\nfunction extend(obj, props) {\n  for (var i in props) {\n    obj[i] = props[i];\n  }return obj;\n}\n\n/**\n * Call a function asynchronously, as soon as possible. Makes\n * use of HTML Promise to schedule the callback if available,\n * otherwise falling back to `setTimeout` (mainly for IE<11).\n *\n * @param {Function} callback\n */\nvar defer = typeof Promise == 'function' ? Promise.resolve().then.bind(Promise.resolve()) : setTimeout;\n\n/**\n * Clones the given VNode, optionally adding attributes/props and replacing its children.\n * @param {VNode} vnode\t\tThe virutal DOM element to clone\n * @param {Object} props\tAttributes/props to add when cloning\n * @param {VNode} rest\t\tAny additional arguments will be used as replacement children.\n */\nfunction cloneElement(vnode, props) {\n  return h(vnode.nodeName, extend(extend({}, vnode.attributes), props), arguments.length > 2 ? [].slice.call(arguments, 2) : vnode.children);\n}\n\n// DOM properties that should NOT have \"px\" added when numeric\nvar IS_NON_DIMENSIONAL = /acit|ex(?:s|g|n|p|$)|rph|ows|mnc|ntw|ine[ch]|zoo|^ord/i;\n\n/** Managed queue of dirty components to be re-rendered */\n\nvar items = [];\n\nfunction enqueueRender(component) {\n\tif (!component._dirty && (component._dirty = true) && items.push(component) == 1) {\n\t\t(options.debounceRendering || defer)(rerender);\n\t}\n}\n\nfunction rerender() {\n\tvar p,\n\t    list = items;\n\titems = [];\n\twhile (p = list.pop()) {\n\t\tif (p._dirty) renderComponent(p);\n\t}\n}\n\n/**\n * Check if two nodes are equivalent.\n *\n * @param {Node} node\t\t\tDOM Node to compare\n * @param {VNode} vnode\t\t\tVirtual DOM node to compare\n * @param {boolean} [hyrdating=false]\tIf true, ignores component constructors when comparing.\n * @private\n */\nfunction isSameNodeType(node, vnode, hydrating) {\n  if (typeof vnode === 'string' || typeof vnode === 'number') {\n    return node.splitText !== undefined;\n  }\n  if (typeof vnode.nodeName === 'string') {\n    return !node._componentConstructor && isNamedNode(node, vnode.nodeName);\n  }\n  return hydrating || node._componentConstructor === vnode.nodeName;\n}\n\n/**\n * Check if an Element has a given nodeName, case-insensitively.\n *\n * @param {Element} node\tA DOM Element to inspect the name of.\n * @param {String} nodeName\tUnnormalized name to compare against.\n */\nfunction isNamedNode(node, nodeName) {\n  return node.normalizedNodeName === nodeName || node.nodeName.toLowerCase() === nodeName.toLowerCase();\n}\n\n/**\n * Reconstruct Component-style `props` from a VNode.\n * Ensures default/fallback values from `defaultProps`:\n * Own-properties of `defaultProps` not present in `vnode.attributes` are added.\n *\n * @param {VNode} vnode\n * @returns {Object} props\n */\nfunction getNodeProps(vnode) {\n  var props = extend({}, vnode.attributes);\n  props.children = vnode.children;\n\n  var defaultProps = vnode.nodeName.defaultProps;\n  if (defaultProps !== undefined) {\n    for (var i in defaultProps) {\n      if (props[i] === undefined) {\n        props[i] = defaultProps[i];\n      }\n    }\n  }\n\n  return props;\n}\n\n/** Create an element with the given nodeName.\n *\t@param {String} nodeName\n *\t@param {Boolean} [isSvg=false]\tIf `true`, creates an element within the SVG namespace.\n *\t@returns {Element} node\n */\nfunction createNode(nodeName, isSvg) {\n\tvar node = isSvg ? document.createElementNS('http://www.w3.org/2000/svg', nodeName) : document.createElement(nodeName);\n\tnode.normalizedNodeName = nodeName;\n\treturn node;\n}\n\n/** Remove a child node from its parent if attached.\n *\t@param {Element} node\t\tThe node to remove\n */\nfunction removeNode(node) {\n\tvar parentNode = node.parentNode;\n\tif (parentNode) parentNode.removeChild(node);\n}\n\n/** Set a named attribute on the given Node, with special behavior for some names and event handlers.\n *\tIf `value` is `null`, the attribute/handler will be removed.\n *\t@param {Element} node\tAn element to mutate\n *\t@param {string} name\tThe name/key to set, such as an event or attribute name\n *\t@param {any} old\tThe last value that was set for this name/node pair\n *\t@param {any} value\tAn attribute value, such as a function to be used as an event handler\n *\t@param {Boolean} isSvg\tAre we currently diffing inside an svg?\n *\t@private\n */\nfunction setAccessor(node, name, old, value, isSvg) {\n\tif (name === 'className') name = 'class';\n\n\tif (name === 'key') {\n\t\t// ignore\n\t} else if (name === 'ref') {\n\t\tif (old) old(null);\n\t\tif (value) value(node);\n\t} else if (name === 'class' && !isSvg) {\n\t\tnode.className = value || '';\n\t} else if (name === 'style') {\n\t\tif (!value || typeof value === 'string' || typeof old === 'string') {\n\t\t\tnode.style.cssText = value || '';\n\t\t}\n\t\tif (value && typeof value === 'object') {\n\t\t\tif (typeof old !== 'string') {\n\t\t\t\tfor (var i in old) {\n\t\t\t\t\tif (!(i in value)) node.style[i] = '';\n\t\t\t\t}\n\t\t\t}\n\t\t\tfor (var i in value) {\n\t\t\t\tnode.style[i] = typeof value[i] === 'number' && IS_NON_DIMENSIONAL.test(i) === false ? value[i] + 'px' : value[i];\n\t\t\t}\n\t\t}\n\t} else if (name === 'dangerouslySetInnerHTML') {\n\t\tif (value) node.innerHTML = value.__html || '';\n\t} else if (name[0] == 'o' && name[1] == 'n') {\n\t\tvar useCapture = name !== (name = name.replace(/Capture$/, ''));\n\t\tname = name.toLowerCase().substring(2);\n\t\tif (value) {\n\t\t\tif (!old) node.addEventListener(name, eventProxy, useCapture);\n\t\t} else {\n\t\t\tnode.removeEventListener(name, eventProxy, useCapture);\n\t\t}\n\t\t(node._listeners || (node._listeners = {}))[name] = value;\n\t} else if (name !== 'list' && name !== 'type' && !isSvg && name in node) {\n\t\tsetProperty(node, name, value == null ? '' : value);\n\t\tif (value == null || value === false) node.removeAttribute(name);\n\t} else {\n\t\tvar ns = isSvg && name !== (name = name.replace(/^xlink\\:?/, ''));\n\t\tif (value == null || value === false) {\n\t\t\tif (ns) node.removeAttributeNS('http://www.w3.org/1999/xlink', name.toLowerCase());else node.removeAttribute(name);\n\t\t} else if (typeof value !== 'function') {\n\t\t\tif (ns) node.setAttributeNS('http://www.w3.org/1999/xlink', name.toLowerCase(), value);else node.setAttribute(name, value);\n\t\t}\n\t}\n}\n\n/** Attempt to set a DOM property to the given value.\n *\tIE & FF throw for certain property-value combinations.\n */\nfunction setProperty(node, name, value) {\n\ttry {\n\t\tnode[name] = value;\n\t} catch (e) {}\n}\n\n/** Proxy an event to hooked event handlers\n *\t@private\n */\nfunction eventProxy(e) {\n\treturn this._listeners[e.type](options.event && options.event(e) || e);\n}\n\n/** Queue of components that have been mounted and are awaiting componentDidMount */\nvar mounts = [];\n\n/** Diff recursion count, used to track the end of the diff cycle. */\nvar diffLevel = 0;\n\n/** Global flag indicating if the diff is currently within an SVG */\nvar isSvgMode = false;\n\n/** Global flag indicating if the diff is performing hydration */\nvar hydrating = false;\n\n/** Invoke queued componentDidMount lifecycle methods */\nfunction flushMounts() {\n\tvar c;\n\twhile (c = mounts.pop()) {\n\t\tif (options.afterMount) options.afterMount(c);\n\t\tif (c.componentDidMount) c.componentDidMount();\n\t}\n}\n\n/** Apply differences in a given vnode (and it's deep children) to a real DOM Node.\n *\t@param {Element} [dom=null]\t\tA DOM node to mutate into the shape of the `vnode`\n *\t@param {VNode} vnode\t\t\tA VNode (with descendants forming a tree) representing the desired DOM structure\n *\t@returns {Element} dom\t\t\tThe created/mutated element\n *\t@private\n */\nfunction diff(dom, vnode, context, mountAll, parent, componentRoot) {\n\t// diffLevel having been 0 here indicates initial entry into the diff (not a subdiff)\n\tif (!diffLevel++) {\n\t\t// when first starting the diff, check if we're diffing an SVG or within an SVG\n\t\tisSvgMode = parent != null && parent.ownerSVGElement !== undefined;\n\n\t\t// hydration is indicated by the existing element to be diffed not having a prop cache\n\t\thydrating = dom != null && !('__preactattr_' in dom);\n\t}\n\n\tvar ret = idiff(dom, vnode, context, mountAll, componentRoot);\n\n\t// append the element if its a new parent\n\tif (parent && ret.parentNode !== parent) parent.appendChild(ret);\n\n\t// diffLevel being reduced to 0 means we're exiting the diff\n\tif (! --diffLevel) {\n\t\thydrating = false;\n\t\t// invoke queued componentDidMount lifecycle methods\n\t\tif (!componentRoot) flushMounts();\n\t}\n\n\treturn ret;\n}\n\n/** Internals of `diff()`, separated to allow bypassing diffLevel / mount flushing. */\nfunction idiff(dom, vnode, context, mountAll, componentRoot) {\n\tvar out = dom,\n\t    prevSvgMode = isSvgMode;\n\n\t// empty values (null, undefined, booleans) render as empty Text nodes\n\tif (vnode == null || typeof vnode === 'boolean') vnode = '';\n\n\t// Fast case: Strings & Numbers create/update Text nodes.\n\tif (typeof vnode === 'string' || typeof vnode === 'number') {\n\n\t\t// update if it's already a Text node:\n\t\tif (dom && dom.splitText !== undefined && dom.parentNode && (!dom._component || componentRoot)) {\n\t\t\t/* istanbul ignore if */ /* Browser quirk that can't be covered: https://github.com/developit/preact/commit/fd4f21f5c45dfd75151bd27b4c217d8003aa5eb9 */\n\t\t\tif (dom.nodeValue != vnode) {\n\t\t\t\tdom.nodeValue = vnode;\n\t\t\t}\n\t\t} else {\n\t\t\t// it wasn't a Text node: replace it with one and recycle the old Element\n\t\t\tout = document.createTextNode(vnode);\n\t\t\tif (dom) {\n\t\t\t\tif (dom.parentNode) dom.parentNode.replaceChild(out, dom);\n\t\t\t\trecollectNodeTree(dom, true);\n\t\t\t}\n\t\t}\n\n\t\tout['__preactattr_'] = true;\n\n\t\treturn out;\n\t}\n\n\t// If the VNode represents a Component, perform a component diff:\n\tvar vnodeName = vnode.nodeName;\n\tif (typeof vnodeName === 'function') {\n\t\treturn buildComponentFromVNode(dom, vnode, context, mountAll);\n\t}\n\n\t// Tracks entering and exiting SVG namespace when descending through the tree.\n\tisSvgMode = vnodeName === 'svg' ? true : vnodeName === 'foreignObject' ? false : isSvgMode;\n\n\t// If there's no existing element or it's the wrong type, create a new one:\n\tvnodeName = String(vnodeName);\n\tif (!dom || !isNamedNode(dom, vnodeName)) {\n\t\tout = createNode(vnodeName, isSvgMode);\n\n\t\tif (dom) {\n\t\t\t// move children into the replacement node\n\t\t\twhile (dom.firstChild) {\n\t\t\t\tout.appendChild(dom.firstChild);\n\t\t\t} // if the previous Element was mounted into the DOM, replace it inline\n\t\t\tif (dom.parentNode) dom.parentNode.replaceChild(out, dom);\n\n\t\t\t// recycle the old element (skips non-Element node types)\n\t\t\trecollectNodeTree(dom, true);\n\t\t}\n\t}\n\n\tvar fc = out.firstChild,\n\t    props = out['__preactattr_'],\n\t    vchildren = vnode.children;\n\n\tif (props == null) {\n\t\tprops = out['__preactattr_'] = {};\n\t\tfor (var a = out.attributes, i = a.length; i--;) {\n\t\t\tprops[a[i].name] = a[i].value;\n\t\t}\n\t}\n\n\t// Optimization: fast-path for elements containing a single TextNode:\n\tif (!hydrating && vchildren && vchildren.length === 1 && typeof vchildren[0] === 'string' && fc != null && fc.splitText !== undefined && fc.nextSibling == null) {\n\t\tif (fc.nodeValue != vchildren[0]) {\n\t\t\tfc.nodeValue = vchildren[0];\n\t\t}\n\t}\n\t// otherwise, if there are existing or new children, diff them:\n\telse if (vchildren && vchildren.length || fc != null) {\n\t\t\tinnerDiffNode(out, vchildren, context, mountAll, hydrating || props.dangerouslySetInnerHTML != null);\n\t\t}\n\n\t// Apply attributes/props from VNode to the DOM Element:\n\tdiffAttributes(out, vnode.attributes, props);\n\n\t// restore previous SVG mode: (in case we're exiting an SVG namespace)\n\tisSvgMode = prevSvgMode;\n\n\treturn out;\n}\n\n/** Apply child and attribute changes between a VNode and a DOM Node to the DOM.\n *\t@param {Element} dom\t\t\tElement whose children should be compared & mutated\n *\t@param {Array} vchildren\t\tArray of VNodes to compare to `dom.childNodes`\n *\t@param {Object} context\t\t\tImplicitly descendant context object (from most recent `getChildContext()`)\n *\t@param {Boolean} mountAll\n *\t@param {Boolean} isHydrating\tIf `true`, consumes externally created elements similar to hydration\n */\nfunction innerDiffNode(dom, vchildren, context, mountAll, isHydrating) {\n\tvar originalChildren = dom.childNodes,\n\t    children = [],\n\t    keyed = {},\n\t    keyedLen = 0,\n\t    min = 0,\n\t    len = originalChildren.length,\n\t    childrenLen = 0,\n\t    vlen = vchildren ? vchildren.length : 0,\n\t    j,\n\t    c,\n\t    f,\n\t    vchild,\n\t    child;\n\n\t// Build up a map of keyed children and an Array of unkeyed children:\n\tif (len !== 0) {\n\t\tfor (var i = 0; i < len; i++) {\n\t\t\tvar _child = originalChildren[i],\n\t\t\t    props = _child['__preactattr_'],\n\t\t\t    key = vlen && props ? _child._component ? _child._component.__key : props.key : null;\n\t\t\tif (key != null) {\n\t\t\t\tkeyedLen++;\n\t\t\t\tkeyed[key] = _child;\n\t\t\t} else if (props || (_child.splitText !== undefined ? isHydrating ? _child.nodeValue.trim() : true : isHydrating)) {\n\t\t\t\tchildren[childrenLen++] = _child;\n\t\t\t}\n\t\t}\n\t}\n\n\tif (vlen !== 0) {\n\t\tfor (var i = 0; i < vlen; i++) {\n\t\t\tvchild = vchildren[i];\n\t\t\tchild = null;\n\n\t\t\t// attempt to find a node based on key matching\n\t\t\tvar key = vchild.key;\n\t\t\tif (key != null) {\n\t\t\t\tif (keyedLen && keyed[key] !== undefined) {\n\t\t\t\t\tchild = keyed[key];\n\t\t\t\t\tkeyed[key] = undefined;\n\t\t\t\t\tkeyedLen--;\n\t\t\t\t}\n\t\t\t}\n\t\t\t// attempt to pluck a node of the same type from the existing children\n\t\t\telse if (!child && min < childrenLen) {\n\t\t\t\t\tfor (j = min; j < childrenLen; j++) {\n\t\t\t\t\t\tif (children[j] !== undefined && isSameNodeType(c = children[j], vchild, isHydrating)) {\n\t\t\t\t\t\t\tchild = c;\n\t\t\t\t\t\t\tchildren[j] = undefined;\n\t\t\t\t\t\t\tif (j === childrenLen - 1) childrenLen--;\n\t\t\t\t\t\t\tif (j === min) min++;\n\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t// morph the matched/found/created DOM child to match vchild (deep)\n\t\t\tchild = idiff(child, vchild, context, mountAll);\n\n\t\t\tf = originalChildren[i];\n\t\t\tif (child && child !== dom && child !== f) {\n\t\t\t\tif (f == null) {\n\t\t\t\t\tdom.appendChild(child);\n\t\t\t\t} else if (child === f.nextSibling) {\n\t\t\t\t\tremoveNode(f);\n\t\t\t\t} else {\n\t\t\t\t\tdom.insertBefore(child, f);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\t// remove unused keyed children:\n\tif (keyedLen) {\n\t\tfor (var i in keyed) {\n\t\t\tif (keyed[i] !== undefined) recollectNodeTree(keyed[i], false);\n\t\t}\n\t}\n\n\t// remove orphaned unkeyed children:\n\twhile (min <= childrenLen) {\n\t\tif ((child = children[childrenLen--]) !== undefined) recollectNodeTree(child, false);\n\t}\n}\n\n/** Recursively recycle (or just unmount) a node and its descendants.\n *\t@param {Node} node\t\t\t\t\t\tDOM node to start unmount/removal from\n *\t@param {Boolean} [unmountOnly=false]\tIf `true`, only triggers unmount lifecycle, skips removal\n */\nfunction recollectNodeTree(node, unmountOnly) {\n\tvar component = node._component;\n\tif (component) {\n\t\t// if node is owned by a Component, unmount that component (ends up recursing back here)\n\t\tunmountComponent(component);\n\t} else {\n\t\t// If the node's VNode had a ref function, invoke it with null here.\n\t\t// (this is part of the React spec, and smart for unsetting references)\n\t\tif (node['__preactattr_'] != null && node['__preactattr_'].ref) node['__preactattr_'].ref(null);\n\n\t\tif (unmountOnly === false || node['__preactattr_'] == null) {\n\t\t\tremoveNode(node);\n\t\t}\n\n\t\tremoveChildren(node);\n\t}\n}\n\n/** Recollect/unmount all children.\n *\t- we use .lastChild here because it causes less reflow than .firstChild\n *\t- it's also cheaper than accessing the .childNodes Live NodeList\n */\nfunction removeChildren(node) {\n\tnode = node.lastChild;\n\twhile (node) {\n\t\tvar next = node.previousSibling;\n\t\trecollectNodeTree(node, true);\n\t\tnode = next;\n\t}\n}\n\n/** Apply differences in attributes from a VNode to the given DOM Element.\n *\t@param {Element} dom\t\tElement with attributes to diff `attrs` against\n *\t@param {Object} attrs\t\tThe desired end-state key-value attribute pairs\n *\t@param {Object} old\t\t\tCurrent/previous attributes (from previous VNode or element's prop cache)\n */\nfunction diffAttributes(dom, attrs, old) {\n\tvar name;\n\n\t// remove attributes no longer present on the vnode by setting them to undefined\n\tfor (name in old) {\n\t\tif (!(attrs && attrs[name] != null) && old[name] != null) {\n\t\t\tsetAccessor(dom, name, old[name], old[name] = undefined, isSvgMode);\n\t\t}\n\t}\n\n\t// add new & update changed attributes\n\tfor (name in attrs) {\n\t\tif (name !== 'children' && name !== 'innerHTML' && (!(name in old) || attrs[name] !== (name === 'value' || name === 'checked' ? dom[name] : old[name]))) {\n\t\t\tsetAccessor(dom, name, old[name], old[name] = attrs[name], isSvgMode);\n\t\t}\n\t}\n}\n\n/** Retains a pool of Components for re-use, keyed on component name.\n *\tNote: since component names are not unique or even necessarily available, these are primarily a form of sharding.\n *\t@private\n */\nvar components = {};\n\n/** Reclaim a component for later re-use by the recycler. */\nfunction collectComponent(component) {\n\tvar name = component.constructor.name;\n\t(components[name] || (components[name] = [])).push(component);\n}\n\n/** Create a component. Normalizes differences between PFC's and classful Components. */\nfunction createComponent(Ctor, props, context) {\n\tvar list = components[Ctor.name],\n\t    inst;\n\n\tif (Ctor.prototype && Ctor.prototype.render) {\n\t\tinst = new Ctor(props, context);\n\t\tComponent.call(inst, props, context);\n\t} else {\n\t\tinst = new Component(props, context);\n\t\tinst.constructor = Ctor;\n\t\tinst.render = doRender;\n\t}\n\n\tif (list) {\n\t\tfor (var i = list.length; i--;) {\n\t\t\tif (list[i].constructor === Ctor) {\n\t\t\t\tinst.nextBase = list[i].nextBase;\n\t\t\t\tlist.splice(i, 1);\n\t\t\t\tbreak;\n\t\t\t}\n\t\t}\n\t}\n\treturn inst;\n}\n\n/** The `.render()` method for a PFC backing instance. */\nfunction doRender(props, state, context) {\n\treturn this.constructor(props, context);\n}\n\n/** Set a component's `props` (generally derived from JSX attributes).\n *\t@param {Object} props\n *\t@param {Object} [opts]\n *\t@param {boolean} [opts.renderSync=false]\tIf `true` and {@link options.syncComponentUpdates} is `true`, triggers synchronous rendering.\n *\t@param {boolean} [opts.render=true]\t\t\tIf `false`, no render will be triggered.\n */\nfunction setComponentProps(component, props, opts, context, mountAll) {\n\tif (component._disable) return;\n\tcomponent._disable = true;\n\n\tif (component.__ref = props.ref) delete props.ref;\n\tif (component.__key = props.key) delete props.key;\n\n\tif (!component.base || mountAll) {\n\t\tif (component.componentWillMount) component.componentWillMount();\n\t} else if (component.componentWillReceiveProps) {\n\t\tcomponent.componentWillReceiveProps(props, context);\n\t}\n\n\tif (context && context !== component.context) {\n\t\tif (!component.prevContext) component.prevContext = component.context;\n\t\tcomponent.context = context;\n\t}\n\n\tif (!component.prevProps) component.prevProps = component.props;\n\tcomponent.props = props;\n\n\tcomponent._disable = false;\n\n\tif (opts !== 0) {\n\t\tif (opts === 1 || options.syncComponentUpdates !== false || !component.base) {\n\t\t\trenderComponent(component, 1, mountAll);\n\t\t} else {\n\t\t\tenqueueRender(component);\n\t\t}\n\t}\n\n\tif (component.__ref) component.__ref(component);\n}\n\n/** Render a Component, triggering necessary lifecycle events and taking High-Order Components into account.\n *\t@param {Component} component\n *\t@param {Object} [opts]\n *\t@param {boolean} [opts.build=false]\t\tIf `true`, component will build and store a DOM node if not already associated with one.\n *\t@private\n */\nfunction renderComponent(component, opts, mountAll, isChild) {\n\tif (component._disable) return;\n\n\tvar props = component.props,\n\t    state = component.state,\n\t    context = component.context,\n\t    previousProps = component.prevProps || props,\n\t    previousState = component.prevState || state,\n\t    previousContext = component.prevContext || context,\n\t    isUpdate = component.base,\n\t    nextBase = component.nextBase,\n\t    initialBase = isUpdate || nextBase,\n\t    initialChildComponent = component._component,\n\t    skip = false,\n\t    rendered,\n\t    inst,\n\t    cbase;\n\n\t// if updating\n\tif (isUpdate) {\n\t\tcomponent.props = previousProps;\n\t\tcomponent.state = previousState;\n\t\tcomponent.context = previousContext;\n\t\tif (opts !== 2 && component.shouldComponentUpdate && component.shouldComponentUpdate(props, state, context) === false) {\n\t\t\tskip = true;\n\t\t} else if (component.componentWillUpdate) {\n\t\t\tcomponent.componentWillUpdate(props, state, context);\n\t\t}\n\t\tcomponent.props = props;\n\t\tcomponent.state = state;\n\t\tcomponent.context = context;\n\t}\n\n\tcomponent.prevProps = component.prevState = component.prevContext = component.nextBase = null;\n\tcomponent._dirty = false;\n\n\tif (!skip) {\n\t\trendered = component.render(props, state, context);\n\n\t\t// context to pass to the child, can be updated via (grand-)parent component\n\t\tif (component.getChildContext) {\n\t\t\tcontext = extend(extend({}, context), component.getChildContext());\n\t\t}\n\n\t\tvar childComponent = rendered && rendered.nodeName,\n\t\t    toUnmount,\n\t\t    base;\n\n\t\tif (typeof childComponent === 'function') {\n\t\t\t// set up high order component link\n\n\t\t\tvar childProps = getNodeProps(rendered);\n\t\t\tinst = initialChildComponent;\n\n\t\t\tif (inst && inst.constructor === childComponent && childProps.key == inst.__key) {\n\t\t\t\tsetComponentProps(inst, childProps, 1, context, false);\n\t\t\t} else {\n\t\t\t\ttoUnmount = inst;\n\n\t\t\t\tcomponent._component = inst = createComponent(childComponent, childProps, context);\n\t\t\t\tinst.nextBase = inst.nextBase || nextBase;\n\t\t\t\tinst._parentComponent = component;\n\t\t\t\tsetComponentProps(inst, childProps, 0, context, false);\n\t\t\t\trenderComponent(inst, 1, mountAll, true);\n\t\t\t}\n\n\t\t\tbase = inst.base;\n\t\t} else {\n\t\t\tcbase = initialBase;\n\n\t\t\t// destroy high order component link\n\t\t\ttoUnmount = initialChildComponent;\n\t\t\tif (toUnmount) {\n\t\t\t\tcbase = component._component = null;\n\t\t\t}\n\n\t\t\tif (initialBase || opts === 1) {\n\t\t\t\tif (cbase) cbase._component = null;\n\t\t\t\tbase = diff(cbase, rendered, context, mountAll || !isUpdate, initialBase && initialBase.parentNode, true);\n\t\t\t}\n\t\t}\n\n\t\tif (initialBase && base !== initialBase && inst !== initialChildComponent) {\n\t\t\tvar baseParent = initialBase.parentNode;\n\t\t\tif (baseParent && base !== baseParent) {\n\t\t\t\tbaseParent.replaceChild(base, initialBase);\n\n\t\t\t\tif (!toUnmount) {\n\t\t\t\t\tinitialBase._component = null;\n\t\t\t\t\trecollectNodeTree(initialBase, false);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\tif (toUnmount) {\n\t\t\tunmountComponent(toUnmount);\n\t\t}\n\n\t\tcomponent.base = base;\n\t\tif (base && !isChild) {\n\t\t\tvar componentRef = component,\n\t\t\t    t = component;\n\t\t\twhile (t = t._parentComponent) {\n\t\t\t\t(componentRef = t).base = base;\n\t\t\t}\n\t\t\tbase._component = componentRef;\n\t\t\tbase._componentConstructor = componentRef.constructor;\n\t\t}\n\t}\n\n\tif (!isUpdate || mountAll) {\n\t\tmounts.unshift(component);\n\t} else if (!skip) {\n\t\t// Ensure that pending componentDidMount() hooks of child components\n\t\t// are called before the componentDidUpdate() hook in the parent.\n\t\t// Note: disabled as it causes duplicate hooks, see https://github.com/developit/preact/issues/750\n\t\t// flushMounts();\n\n\t\tif (component.componentDidUpdate) {\n\t\t\tcomponent.componentDidUpdate(previousProps, previousState, previousContext);\n\t\t}\n\t\tif (options.afterUpdate) options.afterUpdate(component);\n\t}\n\n\tif (component._renderCallbacks != null) {\n\t\twhile (component._renderCallbacks.length) {\n\t\t\tcomponent._renderCallbacks.pop().call(component);\n\t\t}\n\t}\n\n\tif (!diffLevel && !isChild) flushMounts();\n}\n\n/** Apply the Component referenced by a VNode to the DOM.\n *\t@param {Element} dom\tThe DOM node to mutate\n *\t@param {VNode} vnode\tA Component-referencing VNode\n *\t@returns {Element} dom\tThe created/mutated element\n *\t@private\n */\nfunction buildComponentFromVNode(dom, vnode, context, mountAll) {\n\tvar c = dom && dom._component,\n\t    originalComponent = c,\n\t    oldDom = dom,\n\t    isDirectOwner = c && dom._componentConstructor === vnode.nodeName,\n\t    isOwner = isDirectOwner,\n\t    props = getNodeProps(vnode);\n\twhile (c && !isOwner && (c = c._parentComponent)) {\n\t\tisOwner = c.constructor === vnode.nodeName;\n\t}\n\n\tif (c && isOwner && (!mountAll || c._component)) {\n\t\tsetComponentProps(c, props, 3, context, mountAll);\n\t\tdom = c.base;\n\t} else {\n\t\tif (originalComponent && !isDirectOwner) {\n\t\t\tunmountComponent(originalComponent);\n\t\t\tdom = oldDom = null;\n\t\t}\n\n\t\tc = createComponent(vnode.nodeName, props, context);\n\t\tif (dom && !c.nextBase) {\n\t\t\tc.nextBase = dom;\n\t\t\t// passing dom/oldDom as nextBase will recycle it if unused, so bypass recycling on L229:\n\t\t\toldDom = null;\n\t\t}\n\t\tsetComponentProps(c, props, 1, context, mountAll);\n\t\tdom = c.base;\n\n\t\tif (oldDom && dom !== oldDom) {\n\t\t\toldDom._component = null;\n\t\t\trecollectNodeTree(oldDom, false);\n\t\t}\n\t}\n\n\treturn dom;\n}\n\n/** Remove a component from the DOM and recycle it.\n *\t@param {Component} component\tThe Component instance to unmount\n *\t@private\n */\nfunction unmountComponent(component) {\n\tif (options.beforeUnmount) options.beforeUnmount(component);\n\n\tvar base = component.base;\n\n\tcomponent._disable = true;\n\n\tif (component.componentWillUnmount) component.componentWillUnmount();\n\n\tcomponent.base = null;\n\n\t// recursively tear down & recollect high-order component children:\n\tvar inner = component._component;\n\tif (inner) {\n\t\tunmountComponent(inner);\n\t} else if (base) {\n\t\tif (base['__preactattr_'] && base['__preactattr_'].ref) base['__preactattr_'].ref(null);\n\n\t\tcomponent.nextBase = base;\n\n\t\tremoveNode(base);\n\t\tcollectComponent(component);\n\n\t\tremoveChildren(base);\n\t}\n\n\tif (component.__ref) component.__ref(null);\n}\n\n/** Base Component class.\n *\tProvides `setState()` and `forceUpdate()`, which trigger rendering.\n *\t@public\n *\n *\t@example\n *\tclass MyFoo extends Component {\n *\t\trender(props, state) {\n *\t\t\treturn <div />;\n *\t\t}\n *\t}\n */\nfunction Component(props, context) {\n\tthis._dirty = true;\n\n\t/** @public\n  *\t@type {object}\n  */\n\tthis.context = context;\n\n\t/** @public\n  *\t@type {object}\n  */\n\tthis.props = props;\n\n\t/** @public\n  *\t@type {object}\n  */\n\tthis.state = this.state || {};\n}\n\nextend(Component.prototype, {\n\n\t/** Returns a `boolean` indicating if the component should re-render when receiving the given `props` and `state`.\n  *\t@param {object} nextProps\n  *\t@param {object} nextState\n  *\t@param {object} nextContext\n  *\t@returns {Boolean} should the component re-render\n  *\t@name shouldComponentUpdate\n  *\t@function\n  */\n\n\t/** Update component state by copying properties from `state` to `this.state`.\n  *\t@param {object} state\t\tA hash of state properties to update with new values\n  *\t@param {function} callback\tA function to be called once component state is updated\n  */\n\tsetState: function setState(state, callback) {\n\t\tvar s = this.state;\n\t\tif (!this.prevState) this.prevState = extend({}, s);\n\t\textend(s, typeof state === 'function' ? state(s, this.props) : state);\n\t\tif (callback) (this._renderCallbacks = this._renderCallbacks || []).push(callback);\n\t\tenqueueRender(this);\n\t},\n\n\n\t/** Immediately perform a synchronous re-render of the component.\n  *\t@param {function} callback\t\tA function to be called after component is re-rendered.\n  *\t@private\n  */\n\tforceUpdate: function forceUpdate(callback) {\n\t\tif (callback) (this._renderCallbacks = this._renderCallbacks || []).push(callback);\n\t\trenderComponent(this, 2);\n\t},\n\n\n\t/** Accepts `props` and `state`, and returns a new Virtual DOM tree to build.\n  *\tVirtual DOM is generally constructed via [JSX](http://jasonformat.com/wtf-is-jsx).\n  *\t@param {object} props\t\tProps (eg: JSX attributes) received from parent element/component\n  *\t@param {object} state\t\tThe component's current state\n  *\t@param {object} context\t\tContext object (if a parent component has provided context)\n  *\t@returns VNode\n  */\n\trender: function render() {}\n});\n\n/** Render JSX into a `parent` Element.\n *\t@param {VNode} vnode\t\tA (JSX) VNode to render\n *\t@param {Element} parent\t\tDOM element to render into\n *\t@param {Element} [merge]\tAttempt to re-use an existing DOM tree rooted at `merge`\n *\t@public\n *\n *\t@example\n *\t// render a div into <body>:\n *\trender(<div id=\"hello\">hello!</div>, document.body);\n *\n *\t@example\n *\t// render a \"Thing\" component into #foo:\n *\tconst Thing = ({ name }) => <span>{ name }</span>;\n *\trender(<Thing name=\"one\" />, document.querySelector('#foo'));\n */\nfunction render(vnode, parent, merge) {\n  return diff(merge, vnode, {}, false, parent, false);\n}\n\nvar preact = {\n\th: h,\n\tcreateElement: h,\n\tcloneElement: cloneElement,\n\tComponent: Component,\n\trender: render,\n\trerender: rerender,\n\toptions: options\n};\n\nexport { h, h as createElement, cloneElement, Component, render, rerender, options };\nexport default preact;\n//# sourceMappingURL=preact.esm.js.map\n\n\n\n// WEBPACK FOOTER //\n// ./node_modules/preact/dist/preact.esm.js","var g;\r\n\r\n// This works in non-strict mode\r\ng = (function() {\r\n\treturn this;\r\n})();\r\n\r\ntry {\r\n\t// This works if eval is allowed (see CSP)\r\n\tg = g || Function(\"return this\")() || (1,eval)(\"this\");\r\n} catch(e) {\r\n\t// This works if the window reference is available\r\n\tif(typeof window === \"object\")\r\n\t\tg = window;\r\n}\r\n\r\n// g can still be undefined, but nothing to do about it...\r\n// We return undefined, instead of nothing here, so it's\r\n// easier to handle this case. if(!global) { ...}\r\n\r\nmodule.exports = g;\r\n\n\n\n// WEBPACK FOOTER //\n// (webpack)/buildin/global.js","// @flow\n\nexport function bem (blockName: string, ...modifiers: any[]) {\n  return [blockName].concat(modifiers.filter(Boolean).map(modifier => `${blockName}--${modifier}`)).join(' ')\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/lib/bem.js","// @flow @jsx h\nimport { h, Component } from 'preact'\n\ntype ErrorReport = {\n  message: string\n}\n\ntype ProviderProps = {\n  sendErrorReport: (e: ErrorReport) => void,\n  trackAction: (e: string) => void\n}\n\nclass Provider extends Component<ProviderProps & { children: Array<any> }, {}> {\n  getChildContext () {\n    return {\n      sendErrorReport: this.props.sendErrorReport,\n      trackAction: this.props.trackAction\n    }\n  }\n  render () {\n    return this.props.children[0]\n  }\n}\n\nProvider.displayName = 'Provider'\n\ntype MapStateToProps = (...Array<any>) => Object\n\nfunction connect (mapStateToProps?: MapStateToProps) {\n  return (wrappedComponent: any) => {\n    class Connected extends Component<{}, {}> {\n      mapStateToProps = (opts: ProviderProps): Object => {\n        return mapStateToProps ? mapStateToProps(opts) : opts\n      }\n      render () {\n        return h(wrappedComponent, {\n          ...this.mapStateToProps({\n            sendErrorReport: this.context.sendErrorReport,\n            trackAction: this.context.trackAction\n          }),\n          ...this.props\n        })\n      }\n    }\n    Connected.displayName = `connect(${wrappedComponent.displayName || wrappedComponent.name || 'Component'})`\n    return Connected\n  }\n}\n\nexport { Provider, connect }\n\n\n\n// WEBPACK FOOTER //\n// ./src/lib/provider.js","// removed by extract-text-webpack-plugin\nmodule.exports = {\"root\":\"dh-dh-plastic-counter-root\",\"app\":\"dh-dh-plastic-counter-app\",\"app--medium\":\"dh-dh-plastic-counter-app--medium\",\"app--large\":\"dh-dh-plastic-counter-app--large\",\"app--extra-large\":\"dh-dh-plastic-counter-app--extra-large\"};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./src/v1/components/App.css\n// module id = 4\n// module chunks = 0","/* eslint-disable */\nimport 'promise-polyfill/src/polyfill'\nimport 'intersection-observer'\n\n\n\n// WEBPACK FOOTER //\n// ./src/v1/client.polyfill.js","import Promise from './index';\n\nvar global = (function() {\n  // the only reliable means to get the global object is\n  // `Function('return this')()`\n  // However, this causes CSP violations in Chrome apps.\n  if (typeof self !== 'undefined') {\n    return self;\n  }\n  if (typeof window !== 'undefined') {\n    return window;\n  }\n  if (typeof global !== 'undefined') {\n    return global;\n  }\n  throw new Error('unable to locate global object');\n})();\n\nif (!global.Promise) {\n  global.Promise = Promise;\n}\n\n\n\n// WEBPACK FOOTER //\n// ./node_modules/promise-polyfill/src/polyfill.js","// Store setTimeout reference so promise-polyfill will be unaffected by\n// other code modifying setTimeout (like sinon.useFakeTimers())\nvar setTimeoutFunc = setTimeout;\n\nfunction noop() {}\n\n// Polyfill for Function.prototype.bind\nfunction bind(fn, thisArg) {\n  return function() {\n    fn.apply(thisArg, arguments);\n  };\n}\n\nfunction Promise(fn) {\n  if (!(this instanceof Promise))\n    throw new TypeError('Promises must be constructed via new');\n  if (typeof fn !== 'function') throw new TypeError('not a function');\n  this._state = 0;\n  this._handled = false;\n  this._value = undefined;\n  this._deferreds = [];\n\n  doResolve(fn, this);\n}\n\nfunction handle(self, deferred) {\n  while (self._state === 3) {\n    self = self._value;\n  }\n  if (self._state === 0) {\n    self._deferreds.push(deferred);\n    return;\n  }\n  self._handled = true;\n  Promise._immediateFn(function() {\n    var cb = self._state === 1 ? deferred.onFulfilled : deferred.onRejected;\n    if (cb === null) {\n      (self._state === 1 ? resolve : reject)(deferred.promise, self._value);\n      return;\n    }\n    var ret;\n    try {\n      ret = cb(self._value);\n    } catch (e) {\n      reject(deferred.promise, e);\n      return;\n    }\n    resolve(deferred.promise, ret);\n  });\n}\n\nfunction resolve(self, newValue) {\n  try {\n    // Promise Resolution Procedure: https://github.com/promises-aplus/promises-spec#the-promise-resolution-procedure\n    if (newValue === self)\n      throw new TypeError('A promise cannot be resolved with itself.');\n    if (\n      newValue &&\n      (typeof newValue === 'object' || typeof newValue === 'function')\n    ) {\n      var then = newValue.then;\n      if (newValue instanceof Promise) {\n        self._state = 3;\n        self._value = newValue;\n        finale(self);\n        return;\n      } else if (typeof then === 'function') {\n        doResolve(bind(then, newValue), self);\n        return;\n      }\n    }\n    self._state = 1;\n    self._value = newValue;\n    finale(self);\n  } catch (e) {\n    reject(self, e);\n  }\n}\n\nfunction reject(self, newValue) {\n  self._state = 2;\n  self._value = newValue;\n  finale(self);\n}\n\nfunction finale(self) {\n  if (self._state === 2 && self._deferreds.length === 0) {\n    Promise._immediateFn(function() {\n      if (!self._handled) {\n        Promise._unhandledRejectionFn(self._value);\n      }\n    });\n  }\n\n  for (var i = 0, len = self._deferreds.length; i < len; i++) {\n    handle(self, self._deferreds[i]);\n  }\n  self._deferreds = null;\n}\n\nfunction Handler(onFulfilled, onRejected, promise) {\n  this.onFulfilled = typeof onFulfilled === 'function' ? onFulfilled : null;\n  this.onRejected = typeof onRejected === 'function' ? onRejected : null;\n  this.promise = promise;\n}\n\n/**\n * Take a potentially misbehaving resolver function and make sure\n * onFulfilled and onRejected are only called once.\n *\n * Makes no guarantees about asynchrony.\n */\nfunction doResolve(fn, self) {\n  var done = false;\n  try {\n    fn(\n      function(value) {\n        if (done) return;\n        done = true;\n        resolve(self, value);\n      },\n      function(reason) {\n        if (done) return;\n        done = true;\n        reject(self, reason);\n      }\n    );\n  } catch (ex) {\n    if (done) return;\n    done = true;\n    reject(self, ex);\n  }\n}\n\nPromise.prototype['catch'] = function(onRejected) {\n  return this.then(null, onRejected);\n};\n\nPromise.prototype.then = function(onFulfilled, onRejected) {\n  var prom = new this.constructor(noop);\n\n  handle(this, new Handler(onFulfilled, onRejected, prom));\n  return prom;\n};\n\nPromise.prototype['finally'] = function(callback) {\n  var constructor = this.constructor;\n  return this.then(\n    function(value) {\n      return constructor.resolve(callback()).then(function() {\n        return value;\n      });\n    },\n    function(reason) {\n      return constructor.resolve(callback()).then(function() {\n        return constructor.reject(reason);\n      });\n    }\n  );\n};\n\nPromise.all = function(arr) {\n  return new Promise(function(resolve, reject) {\n    if (!arr || typeof arr.length === 'undefined')\n      throw new TypeError('Promise.all accepts an array');\n    var args = Array.prototype.slice.call(arr);\n    if (args.length === 0) return resolve([]);\n    var remaining = args.length;\n\n    function res(i, val) {\n      try {\n        if (val && (typeof val === 'object' || typeof val === 'function')) {\n          var then = val.then;\n          if (typeof then === 'function') {\n            then.call(\n              val,\n              function(val) {\n                res(i, val);\n              },\n              reject\n            );\n            return;\n          }\n        }\n        args[i] = val;\n        if (--remaining === 0) {\n          resolve(args);\n        }\n      } catch (ex) {\n        reject(ex);\n      }\n    }\n\n    for (var i = 0; i < args.length; i++) {\n      res(i, args[i]);\n    }\n  });\n};\n\nPromise.resolve = function(value) {\n  if (value && typeof value === 'object' && value.constructor === Promise) {\n    return value;\n  }\n\n  return new Promise(function(resolve) {\n    resolve(value);\n  });\n};\n\nPromise.reject = function(value) {\n  return new Promise(function(resolve, reject) {\n    reject(value);\n  });\n};\n\nPromise.race = function(values) {\n  return new Promise(function(resolve, reject) {\n    for (var i = 0, len = values.length; i < len; i++) {\n      values[i].then(resolve, reject);\n    }\n  });\n};\n\n// Use polyfill for setImmediate for performance gains\nPromise._immediateFn =\n  (typeof setImmediate === 'function' &&\n    function(fn) {\n      setImmediate(fn);\n    }) ||\n  function(fn) {\n    setTimeoutFunc(fn, 0);\n  };\n\nPromise._unhandledRejectionFn = function _unhandledRejectionFn(err) {\n  if (typeof console !== 'undefined' && console) {\n    console.warn('Possible Unhandled Promise Rejection:', err); // eslint-disable-line no-console\n  }\n};\n\nexport default Promise;\n\n\n\n// WEBPACK FOOTER //\n// ./node_modules/promise-polyfill/src/index.js","var apply = Function.prototype.apply;\n\n// DOM APIs, for completeness\n\nexports.setTimeout = function() {\n  return new Timeout(apply.call(setTimeout, window, arguments), clearTimeout);\n};\nexports.setInterval = function() {\n  return new Timeout(apply.call(setInterval, window, arguments), clearInterval);\n};\nexports.clearTimeout =\nexports.clearInterval = function(timeout) {\n  if (timeout) {\n    timeout.close();\n  }\n};\n\nfunction Timeout(id, clearFn) {\n  this._id = id;\n  this._clearFn = clearFn;\n}\nTimeout.prototype.unref = Timeout.prototype.ref = function() {};\nTimeout.prototype.close = function() {\n  this._clearFn.call(window, this._id);\n};\n\n// Does not start the time, just sets up the members needed.\nexports.enroll = function(item, msecs) {\n  clearTimeout(item._idleTimeoutId);\n  item._idleTimeout = msecs;\n};\n\nexports.unenroll = function(item) {\n  clearTimeout(item._idleTimeoutId);\n  item._idleTimeout = -1;\n};\n\nexports._unrefActive = exports.active = function(item) {\n  clearTimeout(item._idleTimeoutId);\n\n  var msecs = item._idleTimeout;\n  if (msecs >= 0) {\n    item._idleTimeoutId = setTimeout(function onTimeout() {\n      if (item._onTimeout)\n        item._onTimeout();\n    }, msecs);\n  }\n};\n\n// setimmediate attaches itself to the global object\nrequire(\"setimmediate\");\n// On some exotic environments, it's not clear which object `setimmeidate` was\n// able to install onto.  Search each possibility in the same order as the\n// `setimmediate` library.\nexports.setImmediate = (typeof self !== \"undefined\" && self.setImmediate) ||\n                       (typeof global !== \"undefined\" && global.setImmediate) ||\n                       (this && this.setImmediate);\nexports.clearImmediate = (typeof self !== \"undefined\" && self.clearImmediate) ||\n                         (typeof global !== \"undefined\" && global.clearImmediate) ||\n                         (this && this.clearImmediate);\n\n\n\n// WEBPACK FOOTER //\n// ./node_modules/timers-browserify/main.js","(function (global, undefined) {\n    \"use strict\";\n\n    if (global.setImmediate) {\n        return;\n    }\n\n    var nextHandle = 1; // Spec says greater than zero\n    var tasksByHandle = {};\n    var currentlyRunningATask = false;\n    var doc = global.document;\n    var registerImmediate;\n\n    function setImmediate(callback) {\n      // Callback can either be a function or a string\n      if (typeof callback !== \"function\") {\n        callback = new Function(\"\" + callback);\n      }\n      // Copy function arguments\n      var args = new Array(arguments.length - 1);\n      for (var i = 0; i < args.length; i++) {\n          args[i] = arguments[i + 1];\n      }\n      // Store and register the task\n      var task = { callback: callback, args: args };\n      tasksByHandle[nextHandle] = task;\n      registerImmediate(nextHandle);\n      return nextHandle++;\n    }\n\n    function clearImmediate(handle) {\n        delete tasksByHandle[handle];\n    }\n\n    function run(task) {\n        var callback = task.callback;\n        var args = task.args;\n        switch (args.length) {\n        case 0:\n            callback();\n            break;\n        case 1:\n            callback(args[0]);\n            break;\n        case 2:\n            callback(args[0], args[1]);\n            break;\n        case 3:\n            callback(args[0], args[1], args[2]);\n            break;\n        default:\n            callback.apply(undefined, args);\n            break;\n        }\n    }\n\n    function runIfPresent(handle) {\n        // From the spec: \"Wait until any invocations of this algorithm started before this one have completed.\"\n        // So if we're currently running a task, we'll need to delay this invocation.\n        if (currentlyRunningATask) {\n            // Delay by doing a setTimeout. setImmediate was tried instead, but in Firefox 7 it generated a\n            // \"too much recursion\" error.\n            setTimeout(runIfPresent, 0, handle);\n        } else {\n            var task = tasksByHandle[handle];\n            if (task) {\n                currentlyRunningATask = true;\n                try {\n                    run(task);\n                } finally {\n                    clearImmediate(handle);\n                    currentlyRunningATask = false;\n                }\n            }\n        }\n    }\n\n    function installNextTickImplementation() {\n        registerImmediate = function(handle) {\n            process.nextTick(function () { runIfPresent(handle); });\n        };\n    }\n\n    function canUsePostMessage() {\n        // The test against `importScripts` prevents this implementation from being installed inside a web worker,\n        // where `global.postMessage` means something completely different and can't be used for this purpose.\n        if (global.postMessage && !global.importScripts) {\n            var postMessageIsAsynchronous = true;\n            var oldOnMessage = global.onmessage;\n            global.onmessage = function() {\n                postMessageIsAsynchronous = false;\n            };\n            global.postMessage(\"\", \"*\");\n            global.onmessage = oldOnMessage;\n            return postMessageIsAsynchronous;\n        }\n    }\n\n    function installPostMessageImplementation() {\n        // Installs an event handler on `global` for the `message` event: see\n        // * https://developer.mozilla.org/en/DOM/window.postMessage\n        // * http://www.whatwg.org/specs/web-apps/current-work/multipage/comms.html#crossDocumentMessages\n\n        var messagePrefix = \"setImmediate$\" + Math.random() + \"$\";\n        var onGlobalMessage = function(event) {\n            if (event.source === global &&\n                typeof event.data === \"string\" &&\n                event.data.indexOf(messagePrefix) === 0) {\n                runIfPresent(+event.data.slice(messagePrefix.length));\n            }\n        };\n\n        if (global.addEventListener) {\n            global.addEventListener(\"message\", onGlobalMessage, false);\n        } else {\n            global.attachEvent(\"onmessage\", onGlobalMessage);\n        }\n\n        registerImmediate = function(handle) {\n            global.postMessage(messagePrefix + handle, \"*\");\n        };\n    }\n\n    function installMessageChannelImplementation() {\n        var channel = new MessageChannel();\n        channel.port1.onmessage = function(event) {\n            var handle = event.data;\n            runIfPresent(handle);\n        };\n\n        registerImmediate = function(handle) {\n            channel.port2.postMessage(handle);\n        };\n    }\n\n    function installReadyStateChangeImplementation() {\n        var html = doc.documentElement;\n        registerImmediate = function(handle) {\n            // Create a <script> element; its readystatechange event will be fired asynchronously once it is inserted\n            // into the document. Do so, thus queuing up the task. Remember to clean up once it's been called.\n            var script = doc.createElement(\"script\");\n            script.onreadystatechange = function () {\n                runIfPresent(handle);\n                script.onreadystatechange = null;\n                html.removeChild(script);\n                script = null;\n            };\n            html.appendChild(script);\n        };\n    }\n\n    function installSetTimeoutImplementation() {\n        registerImmediate = function(handle) {\n            setTimeout(runIfPresent, 0, handle);\n        };\n    }\n\n    // If supported, we should attach to the prototype of global, since that is where setTimeout et al. live.\n    var attachTo = Object.getPrototypeOf && Object.getPrototypeOf(global);\n    attachTo = attachTo && attachTo.setTimeout ? attachTo : global;\n\n    // Don't get fooled by e.g. browserify environments.\n    if ({}.toString.call(global.process) === \"[object process]\") {\n        // For Node.js before 0.9\n        installNextTickImplementation();\n\n    } else if (canUsePostMessage()) {\n        // For non-IE10 modern browsers\n        installPostMessageImplementation();\n\n    } else if (global.MessageChannel) {\n        // For web workers, where supported\n        installMessageChannelImplementation();\n\n    } else if (doc && \"onreadystatechange\" in doc.createElement(\"script\")) {\n        // For IE 6–8\n        installReadyStateChangeImplementation();\n\n    } else {\n        // For older browsers\n        installSetTimeoutImplementation();\n    }\n\n    attachTo.setImmediate = setImmediate;\n    attachTo.clearImmediate = clearImmediate;\n}(typeof self === \"undefined\" ? typeof global === \"undefined\" ? this : global : self));\n\n\n\n// WEBPACK FOOTER //\n// ./node_modules/setimmediate/setImmediate.js","// shim for using process in browser\nvar process = module.exports = {};\n\n// cached from whatever global is present so that test runners that stub it\n// don't break things.  But we need to wrap it in a try catch in case it is\n// wrapped in strict mode code which doesn't define any globals.  It's inside a\n// function because try/catches deoptimize in certain engines.\n\nvar cachedSetTimeout;\nvar cachedClearTimeout;\n\nfunction defaultSetTimout() {\n    throw new Error('setTimeout has not been defined');\n}\nfunction defaultClearTimeout () {\n    throw new Error('clearTimeout has not been defined');\n}\n(function () {\n    try {\n        if (typeof setTimeout === 'function') {\n            cachedSetTimeout = setTimeout;\n        } else {\n            cachedSetTimeout = defaultSetTimout;\n        }\n    } catch (e) {\n        cachedSetTimeout = defaultSetTimout;\n    }\n    try {\n        if (typeof clearTimeout === 'function') {\n            cachedClearTimeout = clearTimeout;\n        } else {\n            cachedClearTimeout = defaultClearTimeout;\n        }\n    } catch (e) {\n        cachedClearTimeout = defaultClearTimeout;\n    }\n} ())\nfunction runTimeout(fun) {\n    if (cachedSetTimeout === setTimeout) {\n        //normal enviroments in sane situations\n        return setTimeout(fun, 0);\n    }\n    // if setTimeout wasn't available but was latter defined\n    if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {\n        cachedSetTimeout = setTimeout;\n        return setTimeout(fun, 0);\n    }\n    try {\n        // when when somebody has screwed with setTimeout but no I.E. maddness\n        return cachedSetTimeout(fun, 0);\n    } catch(e){\n        try {\n            // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally\n            return cachedSetTimeout.call(null, fun, 0);\n        } catch(e){\n            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error\n            return cachedSetTimeout.call(this, fun, 0);\n        }\n    }\n\n\n}\nfunction runClearTimeout(marker) {\n    if (cachedClearTimeout === clearTimeout) {\n        //normal enviroments in sane situations\n        return clearTimeout(marker);\n    }\n    // if clearTimeout wasn't available but was latter defined\n    if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {\n        cachedClearTimeout = clearTimeout;\n        return clearTimeout(marker);\n    }\n    try {\n        // when when somebody has screwed with setTimeout but no I.E. maddness\n        return cachedClearTimeout(marker);\n    } catch (e){\n        try {\n            // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally\n            return cachedClearTimeout.call(null, marker);\n        } catch (e){\n            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.\n            // Some versions of I.E. have different rules for clearTimeout vs setTimeout\n            return cachedClearTimeout.call(this, marker);\n        }\n    }\n\n\n\n}\nvar queue = [];\nvar draining = false;\nvar currentQueue;\nvar queueIndex = -1;\n\nfunction cleanUpNextTick() {\n    if (!draining || !currentQueue) {\n        return;\n    }\n    draining = false;\n    if (currentQueue.length) {\n        queue = currentQueue.concat(queue);\n    } else {\n        queueIndex = -1;\n    }\n    if (queue.length) {\n        drainQueue();\n    }\n}\n\nfunction drainQueue() {\n    if (draining) {\n        return;\n    }\n    var timeout = runTimeout(cleanUpNextTick);\n    draining = true;\n\n    var len = queue.length;\n    while(len) {\n        currentQueue = queue;\n        queue = [];\n        while (++queueIndex < len) {\n            if (currentQueue) {\n                currentQueue[queueIndex].run();\n            }\n        }\n        queueIndex = -1;\n        len = queue.length;\n    }\n    currentQueue = null;\n    draining = false;\n    runClearTimeout(timeout);\n}\n\nprocess.nextTick = function (fun) {\n    var args = new Array(arguments.length - 1);\n    if (arguments.length > 1) {\n        for (var i = 1; i < arguments.length; i++) {\n            args[i - 1] = arguments[i];\n        }\n    }\n    queue.push(new Item(fun, args));\n    if (queue.length === 1 && !draining) {\n        runTimeout(drainQueue);\n    }\n};\n\n// v8 likes predictible objects\nfunction Item(fun, array) {\n    this.fun = fun;\n    this.array = array;\n}\nItem.prototype.run = function () {\n    this.fun.apply(null, this.array);\n};\nprocess.title = 'browser';\nprocess.browser = true;\nprocess.env = {};\nprocess.argv = [];\nprocess.version = ''; // empty string to avoid regexp issues\nprocess.versions = {};\n\nfunction noop() {}\n\nprocess.on = noop;\nprocess.addListener = noop;\nprocess.once = noop;\nprocess.off = noop;\nprocess.removeListener = noop;\nprocess.removeAllListeners = noop;\nprocess.emit = noop;\nprocess.prependListener = noop;\nprocess.prependOnceListener = noop;\n\nprocess.listeners = function (name) { return [] }\n\nprocess.binding = function (name) {\n    throw new Error('process.binding is not supported');\n};\n\nprocess.cwd = function () { return '/' };\nprocess.chdir = function (dir) {\n    throw new Error('process.chdir is not supported');\n};\nprocess.umask = function() { return 0; };\n\n\n\n// WEBPACK FOOTER //\n// ./node_modules/process/browser.js","/**\n * Copyright 2016 Google Inc. All Rights Reserved.\n *\n * Licensed under the W3C SOFTWARE AND DOCUMENT NOTICE AND LICENSE.\n *\n *  https://www.w3.org/Consortium/Legal/2015/copyright-software-and-document\n *\n */\n\n(function(window, document) {\n'use strict';\n\n\n// Exits early if all IntersectionObserver and IntersectionObserverEntry\n// features are natively supported.\nif ('IntersectionObserver' in window &&\n    'IntersectionObserverEntry' in window &&\n    'intersectionRatio' in window.IntersectionObserverEntry.prototype) {\n\n  // Minimal polyfill for Edge 15's lack of `isIntersecting`\n  // See: https://github.com/w3c/IntersectionObserver/issues/211\n  if (!('isIntersecting' in window.IntersectionObserverEntry.prototype)) {\n    Object.defineProperty(window.IntersectionObserverEntry.prototype,\n      'isIntersecting', {\n      get: function () {\n        return this.intersectionRatio > 0;\n      }\n    });\n  }\n  return;\n}\n\n\n/**\n * An IntersectionObserver registry. This registry exists to hold a strong\n * reference to IntersectionObserver instances currently observering a target\n * element. Without this registry, instances without another reference may be\n * garbage collected.\n */\nvar registry = [];\n\n\n/**\n * Creates the global IntersectionObserverEntry constructor.\n * https://w3c.github.io/IntersectionObserver/#intersection-observer-entry\n * @param {Object} entry A dictionary of instance properties.\n * @constructor\n */\nfunction IntersectionObserverEntry(entry) {\n  this.time = entry.time;\n  this.target = entry.target;\n  this.rootBounds = entry.rootBounds;\n  this.boundingClientRect = entry.boundingClientRect;\n  this.intersectionRect = entry.intersectionRect || getEmptyRect();\n  this.isIntersecting = !!entry.intersectionRect;\n\n  // Calculates the intersection ratio.\n  var targetRect = this.boundingClientRect;\n  var targetArea = targetRect.width * targetRect.height;\n  var intersectionRect = this.intersectionRect;\n  var intersectionArea = intersectionRect.width * intersectionRect.height;\n\n  // Sets intersection ratio.\n  if (targetArea) {\n    this.intersectionRatio = intersectionArea / targetArea;\n  } else {\n    // If area is zero and is intersecting, sets to 1, otherwise to 0\n    this.intersectionRatio = this.isIntersecting ? 1 : 0;\n  }\n}\n\n\n/**\n * Creates the global IntersectionObserver constructor.\n * https://w3c.github.io/IntersectionObserver/#intersection-observer-interface\n * @param {Function} callback The function to be invoked after intersection\n *     changes have queued. The function is not invoked if the queue has\n *     been emptied by calling the `takeRecords` method.\n * @param {Object=} opt_options Optional configuration options.\n * @constructor\n */\nfunction IntersectionObserver(callback, opt_options) {\n\n  var options = opt_options || {};\n\n  if (typeof callback != 'function') {\n    throw new Error('callback must be a function');\n  }\n\n  if (options.root && options.root.nodeType != 1) {\n    throw new Error('root must be an Element');\n  }\n\n  // Binds and throttles `this._checkForIntersections`.\n  this._checkForIntersections = throttle(\n      this._checkForIntersections.bind(this), this.THROTTLE_TIMEOUT);\n\n  // Private properties.\n  this._callback = callback;\n  this._observationTargets = [];\n  this._queuedEntries = [];\n  this._rootMarginValues = this._parseRootMargin(options.rootMargin);\n\n  // Public properties.\n  this.thresholds = this._initThresholds(options.threshold);\n  this.root = options.root || null;\n  this.rootMargin = this._rootMarginValues.map(function(margin) {\n    return margin.value + margin.unit;\n  }).join(' ');\n}\n\n\n/**\n * The minimum interval within which the document will be checked for\n * intersection changes.\n */\nIntersectionObserver.prototype.THROTTLE_TIMEOUT = 100;\n\n\n/**\n * The frequency in which the polyfill polls for intersection changes.\n * this can be updated on a per instance basis and must be set prior to\n * calling `observe` on the first target.\n */\nIntersectionObserver.prototype.POLL_INTERVAL = null;\n\n/**\n * Use a mutation observer on the root element\n * to detect intersection changes.\n */\nIntersectionObserver.prototype.USE_MUTATION_OBSERVER = true;\n\n\n/**\n * Starts observing a target element for intersection changes based on\n * the thresholds values.\n * @param {Element} target The DOM element to observe.\n */\nIntersectionObserver.prototype.observe = function(target) {\n  var isTargetAlreadyObserved = this._observationTargets.some(function(item) {\n    return item.element == target;\n  });\n\n  if (isTargetAlreadyObserved) {\n    return;\n  }\n\n  if (!(target && target.nodeType == 1)) {\n    throw new Error('target must be an Element');\n  }\n\n  this._registerInstance();\n  this._observationTargets.push({element: target, entry: null});\n  this._monitorIntersections();\n  this._checkForIntersections();\n};\n\n\n/**\n * Stops observing a target element for intersection changes.\n * @param {Element} target The DOM element to observe.\n */\nIntersectionObserver.prototype.unobserve = function(target) {\n  this._observationTargets =\n      this._observationTargets.filter(function(item) {\n\n    return item.element != target;\n  });\n  if (!this._observationTargets.length) {\n    this._unmonitorIntersections();\n    this._unregisterInstance();\n  }\n};\n\n\n/**\n * Stops observing all target elements for intersection changes.\n */\nIntersectionObserver.prototype.disconnect = function() {\n  this._observationTargets = [];\n  this._unmonitorIntersections();\n  this._unregisterInstance();\n};\n\n\n/**\n * Returns any queue entries that have not yet been reported to the\n * callback and clears the queue. This can be used in conjunction with the\n * callback to obtain the absolute most up-to-date intersection information.\n * @return {Array} The currently queued entries.\n */\nIntersectionObserver.prototype.takeRecords = function() {\n  var records = this._queuedEntries.slice();\n  this._queuedEntries = [];\n  return records;\n};\n\n\n/**\n * Accepts the threshold value from the user configuration object and\n * returns a sorted array of unique threshold values. If a value is not\n * between 0 and 1 and error is thrown.\n * @private\n * @param {Array|number=} opt_threshold An optional threshold value or\n *     a list of threshold values, defaulting to [0].\n * @return {Array} A sorted list of unique and valid threshold values.\n */\nIntersectionObserver.prototype._initThresholds = function(opt_threshold) {\n  var threshold = opt_threshold || [0];\n  if (!Array.isArray(threshold)) threshold = [threshold];\n\n  return threshold.sort().filter(function(t, i, a) {\n    if (typeof t != 'number' || isNaN(t) || t < 0 || t > 1) {\n      throw new Error('threshold must be a number between 0 and 1 inclusively');\n    }\n    return t !== a[i - 1];\n  });\n};\n\n\n/**\n * Accepts the rootMargin value from the user configuration object\n * and returns an array of the four margin values as an object containing\n * the value and unit properties. If any of the values are not properly\n * formatted or use a unit other than px or %, and error is thrown.\n * @private\n * @param {string=} opt_rootMargin An optional rootMargin value,\n *     defaulting to '0px'.\n * @return {Array<Object>} An array of margin objects with the keys\n *     value and unit.\n */\nIntersectionObserver.prototype._parseRootMargin = function(opt_rootMargin) {\n  var marginString = opt_rootMargin || '0px';\n  var margins = marginString.split(/\\s+/).map(function(margin) {\n    var parts = /^(-?\\d*\\.?\\d+)(px|%)$/.exec(margin);\n    if (!parts) {\n      throw new Error('rootMargin must be specified in pixels or percent');\n    }\n    return {value: parseFloat(parts[1]), unit: parts[2]};\n  });\n\n  // Handles shorthand.\n  margins[1] = margins[1] || margins[0];\n  margins[2] = margins[2] || margins[0];\n  margins[3] = margins[3] || margins[1];\n\n  return margins;\n};\n\n\n/**\n * Starts polling for intersection changes if the polling is not already\n * happening, and if the page's visibilty state is visible.\n * @private\n */\nIntersectionObserver.prototype._monitorIntersections = function() {\n  if (!this._monitoringIntersections) {\n    this._monitoringIntersections = true;\n\n    // If a poll interval is set, use polling instead of listening to\n    // resize and scroll events or DOM mutations.\n    if (this.POLL_INTERVAL) {\n      this._monitoringInterval = setInterval(\n          this._checkForIntersections, this.POLL_INTERVAL);\n    }\n    else {\n      addEvent(window, 'resize', this._checkForIntersections, true);\n      addEvent(document, 'scroll', this._checkForIntersections, true);\n\n      if (this.USE_MUTATION_OBSERVER && 'MutationObserver' in window) {\n        this._domObserver = new MutationObserver(this._checkForIntersections);\n        this._domObserver.observe(document, {\n          attributes: true,\n          childList: true,\n          characterData: true,\n          subtree: true\n        });\n      }\n    }\n  }\n};\n\n\n/**\n * Stops polling for intersection changes.\n * @private\n */\nIntersectionObserver.prototype._unmonitorIntersections = function() {\n  if (this._monitoringIntersections) {\n    this._monitoringIntersections = false;\n\n    clearInterval(this._monitoringInterval);\n    this._monitoringInterval = null;\n\n    removeEvent(window, 'resize', this._checkForIntersections, true);\n    removeEvent(document, 'scroll', this._checkForIntersections, true);\n\n    if (this._domObserver) {\n      this._domObserver.disconnect();\n      this._domObserver = null;\n    }\n  }\n};\n\n\n/**\n * Scans each observation target for intersection changes and adds them\n * to the internal entries queue. If new entries are found, it\n * schedules the callback to be invoked.\n * @private\n */\nIntersectionObserver.prototype._checkForIntersections = function() {\n  var rootIsInDom = this._rootIsInDom();\n  var rootRect = rootIsInDom ? this._getRootRect() : getEmptyRect();\n\n  this._observationTargets.forEach(function(item) {\n    var target = item.element;\n    var targetRect = getBoundingClientRect(target);\n    var rootContainsTarget = this._rootContainsTarget(target);\n    var oldEntry = item.entry;\n    var intersectionRect = rootIsInDom && rootContainsTarget &&\n        this._computeTargetAndRootIntersection(target, rootRect);\n\n    var newEntry = item.entry = new IntersectionObserverEntry({\n      time: now(),\n      target: target,\n      boundingClientRect: targetRect,\n      rootBounds: rootRect,\n      intersectionRect: intersectionRect\n    });\n\n    if (!oldEntry) {\n      this._queuedEntries.push(newEntry);\n    } else if (rootIsInDom && rootContainsTarget) {\n      // If the new entry intersection ratio has crossed any of the\n      // thresholds, add a new entry.\n      if (this._hasCrossedThreshold(oldEntry, newEntry)) {\n        this._queuedEntries.push(newEntry);\n      }\n    } else {\n      // If the root is not in the DOM or target is not contained within\n      // root but the previous entry for this target had an intersection,\n      // add a new record indicating removal.\n      if (oldEntry && oldEntry.isIntersecting) {\n        this._queuedEntries.push(newEntry);\n      }\n    }\n  }, this);\n\n  if (this._queuedEntries.length) {\n    this._callback(this.takeRecords(), this);\n  }\n};\n\n\n/**\n * Accepts a target and root rect computes the intersection between then\n * following the algorithm in the spec.\n * TODO(philipwalton): at this time clip-path is not considered.\n * https://w3c.github.io/IntersectionObserver/#calculate-intersection-rect-algo\n * @param {Element} target The target DOM element\n * @param {Object} rootRect The bounding rect of the root after being\n *     expanded by the rootMargin value.\n * @return {?Object} The final intersection rect object or undefined if no\n *     intersection is found.\n * @private\n */\nIntersectionObserver.prototype._computeTargetAndRootIntersection =\n    function(target, rootRect) {\n\n  // If the element isn't displayed, an intersection can't happen.\n  if (window.getComputedStyle(target).display == 'none') return;\n\n  var targetRect = getBoundingClientRect(target);\n  var intersectionRect = targetRect;\n  var parent = getParentNode(target);\n  var atRoot = false;\n\n  while (!atRoot) {\n    var parentRect = null;\n    var parentComputedStyle = parent.nodeType == 1 ?\n        window.getComputedStyle(parent) : {};\n\n    // If the parent isn't displayed, an intersection can't happen.\n    if (parentComputedStyle.display == 'none') return;\n\n    if (parent == this.root || parent == document) {\n      atRoot = true;\n      parentRect = rootRect;\n    } else {\n      // If the element has a non-visible overflow, and it's not the <body>\n      // or <html> element, update the intersection rect.\n      // Note: <body> and <html> cannot be clipped to a rect that's not also\n      // the document rect, so no need to compute a new intersection.\n      if (parent != document.body &&\n          parent != document.documentElement &&\n          parentComputedStyle.overflow != 'visible') {\n        parentRect = getBoundingClientRect(parent);\n      }\n    }\n\n    // If either of the above conditionals set a new parentRect,\n    // calculate new intersection data.\n    if (parentRect) {\n      intersectionRect = computeRectIntersection(parentRect, intersectionRect);\n\n      if (!intersectionRect) break;\n    }\n    parent = getParentNode(parent);\n  }\n  return intersectionRect;\n};\n\n\n/**\n * Returns the root rect after being expanded by the rootMargin value.\n * @return {Object} The expanded root rect.\n * @private\n */\nIntersectionObserver.prototype._getRootRect = function() {\n  var rootRect;\n  if (this.root) {\n    rootRect = getBoundingClientRect(this.root);\n  } else {\n    // Use <html>/<body> instead of window since scroll bars affect size.\n    var html = document.documentElement;\n    var body = document.body;\n    rootRect = {\n      top: 0,\n      left: 0,\n      right: html.clientWidth || body.clientWidth,\n      width: html.clientWidth || body.clientWidth,\n      bottom: html.clientHeight || body.clientHeight,\n      height: html.clientHeight || body.clientHeight\n    };\n  }\n  return this._expandRectByRootMargin(rootRect);\n};\n\n\n/**\n * Accepts a rect and expands it by the rootMargin value.\n * @param {Object} rect The rect object to expand.\n * @return {Object} The expanded rect.\n * @private\n */\nIntersectionObserver.prototype._expandRectByRootMargin = function(rect) {\n  var margins = this._rootMarginValues.map(function(margin, i) {\n    return margin.unit == 'px' ? margin.value :\n        margin.value * (i % 2 ? rect.width : rect.height) / 100;\n  });\n  var newRect = {\n    top: rect.top - margins[0],\n    right: rect.right + margins[1],\n    bottom: rect.bottom + margins[2],\n    left: rect.left - margins[3]\n  };\n  newRect.width = newRect.right - newRect.left;\n  newRect.height = newRect.bottom - newRect.top;\n\n  return newRect;\n};\n\n\n/**\n * Accepts an old and new entry and returns true if at least one of the\n * threshold values has been crossed.\n * @param {?IntersectionObserverEntry} oldEntry The previous entry for a\n *    particular target element or null if no previous entry exists.\n * @param {IntersectionObserverEntry} newEntry The current entry for a\n *    particular target element.\n * @return {boolean} Returns true if a any threshold has been crossed.\n * @private\n */\nIntersectionObserver.prototype._hasCrossedThreshold =\n    function(oldEntry, newEntry) {\n\n  // To make comparing easier, an entry that has a ratio of 0\n  // but does not actually intersect is given a value of -1\n  var oldRatio = oldEntry && oldEntry.isIntersecting ?\n      oldEntry.intersectionRatio || 0 : -1;\n  var newRatio = newEntry.isIntersecting ?\n      newEntry.intersectionRatio || 0 : -1;\n\n  // Ignore unchanged ratios\n  if (oldRatio === newRatio) return;\n\n  for (var i = 0; i < this.thresholds.length; i++) {\n    var threshold = this.thresholds[i];\n\n    // Return true if an entry matches a threshold or if the new ratio\n    // and the old ratio are on the opposite sides of a threshold.\n    if (threshold == oldRatio || threshold == newRatio ||\n        threshold < oldRatio !== threshold < newRatio) {\n      return true;\n    }\n  }\n};\n\n\n/**\n * Returns whether or not the root element is an element and is in the DOM.\n * @return {boolean} True if the root element is an element and is in the DOM.\n * @private\n */\nIntersectionObserver.prototype._rootIsInDom = function() {\n  return !this.root || containsDeep(document, this.root);\n};\n\n\n/**\n * Returns whether or not the target element is a child of root.\n * @param {Element} target The target element to check.\n * @return {boolean} True if the target element is a child of root.\n * @private\n */\nIntersectionObserver.prototype._rootContainsTarget = function(target) {\n  return containsDeep(this.root || document, target);\n};\n\n\n/**\n * Adds the instance to the global IntersectionObserver registry if it isn't\n * already present.\n * @private\n */\nIntersectionObserver.prototype._registerInstance = function() {\n  if (registry.indexOf(this) < 0) {\n    registry.push(this);\n  }\n};\n\n\n/**\n * Removes the instance from the global IntersectionObserver registry.\n * @private\n */\nIntersectionObserver.prototype._unregisterInstance = function() {\n  var index = registry.indexOf(this);\n  if (index != -1) registry.splice(index, 1);\n};\n\n\n/**\n * Returns the result of the performance.now() method or null in browsers\n * that don't support the API.\n * @return {number} The elapsed time since the page was requested.\n */\nfunction now() {\n  return window.performance && performance.now && performance.now();\n}\n\n\n/**\n * Throttles a function and delays its executiong, so it's only called at most\n * once within a given time period.\n * @param {Function} fn The function to throttle.\n * @param {number} timeout The amount of time that must pass before the\n *     function can be called again.\n * @return {Function} The throttled function.\n */\nfunction throttle(fn, timeout) {\n  var timer = null;\n  return function () {\n    if (!timer) {\n      timer = setTimeout(function() {\n        fn();\n        timer = null;\n      }, timeout);\n    }\n  };\n}\n\n\n/**\n * Adds an event handler to a DOM node ensuring cross-browser compatibility.\n * @param {Node} node The DOM node to add the event handler to.\n * @param {string} event The event name.\n * @param {Function} fn The event handler to add.\n * @param {boolean} opt_useCapture Optionally adds the even to the capture\n *     phase. Note: this only works in modern browsers.\n */\nfunction addEvent(node, event, fn, opt_useCapture) {\n  if (typeof node.addEventListener == 'function') {\n    node.addEventListener(event, fn, opt_useCapture || false);\n  }\n  else if (typeof node.attachEvent == 'function') {\n    node.attachEvent('on' + event, fn);\n  }\n}\n\n\n/**\n * Removes a previously added event handler from a DOM node.\n * @param {Node} node The DOM node to remove the event handler from.\n * @param {string} event The event name.\n * @param {Function} fn The event handler to remove.\n * @param {boolean} opt_useCapture If the event handler was added with this\n *     flag set to true, it should be set to true here in order to remove it.\n */\nfunction removeEvent(node, event, fn, opt_useCapture) {\n  if (typeof node.removeEventListener == 'function') {\n    node.removeEventListener(event, fn, opt_useCapture || false);\n  }\n  else if (typeof node.detatchEvent == 'function') {\n    node.detatchEvent('on' + event, fn);\n  }\n}\n\n\n/**\n * Returns the intersection between two rect objects.\n * @param {Object} rect1 The first rect.\n * @param {Object} rect2 The second rect.\n * @return {?Object} The intersection rect or undefined if no intersection\n *     is found.\n */\nfunction computeRectIntersection(rect1, rect2) {\n  var top = Math.max(rect1.top, rect2.top);\n  var bottom = Math.min(rect1.bottom, rect2.bottom);\n  var left = Math.max(rect1.left, rect2.left);\n  var right = Math.min(rect1.right, rect2.right);\n  var width = right - left;\n  var height = bottom - top;\n\n  return (width >= 0 && height >= 0) && {\n    top: top,\n    bottom: bottom,\n    left: left,\n    right: right,\n    width: width,\n    height: height\n  };\n}\n\n\n/**\n * Shims the native getBoundingClientRect for compatibility with older IE.\n * @param {Element} el The element whose bounding rect to get.\n * @return {Object} The (possibly shimmed) rect of the element.\n */\nfunction getBoundingClientRect(el) {\n  var rect;\n\n  try {\n    rect = el.getBoundingClientRect();\n  } catch (err) {\n    // Ignore Windows 7 IE11 \"Unspecified error\"\n    // https://github.com/w3c/IntersectionObserver/pull/205\n  }\n\n  if (!rect) return getEmptyRect();\n\n  // Older IE\n  if (!(rect.width && rect.height)) {\n    rect = {\n      top: rect.top,\n      right: rect.right,\n      bottom: rect.bottom,\n      left: rect.left,\n      width: rect.right - rect.left,\n      height: rect.bottom - rect.top\n    };\n  }\n  return rect;\n}\n\n\n/**\n * Returns an empty rect object. An empty rect is returned when an element\n * is not in the DOM.\n * @return {Object} The empty rect.\n */\nfunction getEmptyRect() {\n  return {\n    top: 0,\n    bottom: 0,\n    left: 0,\n    right: 0,\n    width: 0,\n    height: 0\n  };\n}\n\n/**\n * Checks to see if a parent element contains a child elemnt (including inside\n * shadow DOM).\n * @param {Node} parent The parent element.\n * @param {Node} child The child element.\n * @return {boolean} True if the parent node contains the child node.\n */\nfunction containsDeep(parent, child) {\n  var node = child;\n  while (node) {\n    if (node == parent) return true;\n\n    node = getParentNode(node);\n  }\n  return false;\n}\n\n\n/**\n * Gets the parent node of an element or its host element if the parent node\n * is a shadow root.\n * @param {Node} node The node whose parent to get.\n * @return {Node|null} The parent node or null if no parent exists.\n */\nfunction getParentNode(node) {\n  var parent = node.parentNode;\n\n  if (parent && parent.nodeType == 11 && parent.host) {\n    // If the parent is a shadow root, return the host element.\n    return parent.host;\n  }\n  return parent;\n}\n\n\n// Exposes the constructors globally.\nwindow.IntersectionObserver = IntersectionObserver;\nwindow.IntersectionObserverEntry = IntersectionObserverEntry;\n\n}(window, document));\n\n\n\n// WEBPACK FOOTER //\n// ./node_modules/intersection-observer/intersection-observer.js","/* global __HOT__ */\n/** @jsx h */\nimport domready from 'domready'\nimport { render, h } from 'preact'\nimport { nodelistToArray } from '../lib/nodelistToArray'\nimport { uuid } from '../lib/uuid'\nimport { createErrorReporter } from '../lib/errorReporting'\nimport { Provider } from '../lib/provider'\nimport { App } from './components/App'\nimport { root as rootElementClassName } from './components/App.css'\nimport { createGoogleAnalyticsTracker } from '@nrk/dh-analytics-utils'\nimport { getContextId } from '../lib/getContextId'\n\nwindow[rootElementClassName] = window[rootElementClassName] || {}\n\nfunction init () {\n  findElements().forEach(el => {\n    el.id = uuid()\n    window[rootElementClassName][el.id] = true\n\n    // Extract preloaded state sent from server\n    const preloadedState = JSON.parse(el.getAttribute('data-preloaded-state'))\n    const { errorEventTrackingEnabled } = preloadedState\n    const simpleErrorReport = createErrorReporter(errorEventTrackingEnabled)\n    simpleErrorReport.listenAndCatch()\n\n    // Extract metadata required to create google analytics tracker\n    const gaPropertyId = el.getAttribute('data-ga-property-id')\n    const metadata = JSON.parse(el.getAttribute('data-metadata'))\n    const { title, selfId, published } = metadata\n\n    // create google analytics tracker\n    const googleAnalyticsTracker = createGoogleAnalyticsTracker({\n      name: 'dh',\n      gaPropertyId,\n      self: {\n        id: selfId,\n        title,\n        publishedDate: published ? new Date(published) : null\n      },\n      context: {\n        id: getContextId(document.location.href)\n      }\n    })\n\n    const sendErrorReport = (message) => {\n      simpleErrorReport.sendErrorReport({ message })\n    }\n\n    const trackAction = (action, value) => {\n      const eventObj = {\n        category: 'spesialmodul',\n        action,\n        label: 'dh-plastic-counter'\n      }\n      if (value) {\n        eventObj.value = value\n      }\n      googleAnalyticsTracker.sendEvent(eventObj)\n    }\n\n    // ... and render with the exact same props\n    render(\n      <Provider sendErrorReport={sendErrorReport} trackAction={trackAction}>\n        <App {...preloadedState} />\n      </Provider>,\n      el, el.firstChild)\n\n    // Enable webpack hot-reloading\n    if (__HOT__) {\n      // Reload and re-render React application\n      require('preact/debug')\n      module.hot.accept('./client', () => {\n        render(require('./components/App').default, el, el.firstChild)\n      })\n    }\n  })\n}\n\nfunction findElements () {\n  return nodelistToArray(document.getElementsByClassName(rootElementClassName))\n    .filter(el => !isInitialized(el))\n}\n\nfunction isInitialized (el) {\n  return el.id && window[rootElementClassName][el.id]\n}\n\ndomready(init)\n\n\n\n// WEBPACK FOOTER //\n// ./src/v1/client.js","/*!\n  * domready (c) Dustin Diaz 2014 - License MIT\n  */\n!function (name, definition) {\n\n  if (typeof module != 'undefined') module.exports = definition()\n  else if (typeof define == 'function' && typeof define.amd == 'object') define(definition)\n  else this[name] = definition()\n\n}('domready', function () {\n\n  var fns = [], listener\n    , doc = document\n    , hack = doc.documentElement.doScroll\n    , domContentLoaded = 'DOMContentLoaded'\n    , loaded = (hack ? /^loaded|^c/ : /^loaded|^i|^c/).test(doc.readyState)\n\n\n  if (!loaded)\n  doc.addEventListener(domContentLoaded, listener = function () {\n    doc.removeEventListener(domContentLoaded, listener)\n    loaded = 1\n    while (listener = fns.shift()) listener()\n  })\n\n  return function (fn) {\n    loaded ? setTimeout(fn, 0) : fns.push(fn)\n  }\n\n});\n\n\n\n// WEBPACK FOOTER //\n// ./node_modules/domready/ready.js","export function nodelistToArray (nodeList) {\n  return [].slice.call(nodeList)\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/lib/nodelistToArray.js","export function uuid () {\n  return `_${Math.random().toString(36).substr(2, 9)}`\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/lib/uuid.js","// @flow\nimport { SimpleErrorReport } from '@nrk/dh-simple-error-report'\n\nexport function createErrorReporter (isErrorReportingEnabled: boolean): SimpleErrorReport {\n  return new SimpleErrorReport({\n    name: 'dh-plastic-counter',\n    url: 'https://dh.nrk.no/catch',\n    dryRun: !isErrorReportingEnabled\n  })\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/lib/errorReporting.js","!function(e,n){\"object\"==typeof exports&&\"undefined\"!=typeof module?n(exports):\"function\"==typeof define&&define.amd?define([\"exports\"],n):n(e[\"simple-error-report\"]={})}(this,function(e){\"use strict\";var n=function(){function e(e,n){for(var r=0;r<n.length;r++){var t=n[r];t.enumerable=t.enumerable||!1,t.configurable=!0,\"value\"in t&&(t.writable=!0),Object.defineProperty(e,t.key,t)}}return function(n,r,t){return r&&e(n.prototype,r),t&&e(n,t),n}}();var r=function(){function e(){!function(e,n){if(!(e instanceof n))throw new TypeError(\"Cannot call a class as a function\")}(this,e),this.register=[]}return n(e,[{key:\"addErrorToRegister\",value:function(e){this.register.push({time:new Date,message:e})}},{key:\"isInRegisterWithinRange\",value:function(e,n){return this.register.filter(function(r){return r.message===e&&new Date-r.time<n}).length>0}}]),e}(),t=function(){function e(e,n){for(var r=0;r<n.length;r++){var t=n[r];t.enumerable=t.enumerable||!1,t.configurable=!0,\"value\"in t&&(t.writable=!0),Object.defineProperty(e,t.key,t)}}return function(n,r,t){return r&&e(n.prototype,r),t&&e(n,t),n}}();var i=[],o=function(){function e(n){var t=n.name,o=n.url,s=n.dryRun,a=void 0===s||s;!function(e,n){if(!(e instanceof n))throw new TypeError(\"Cannot call a class as a function\")}(this,e),this.name=t,this.url=o,this.errorRegister=new r,this.dryRun=a,i.push(this.name)}return t(e,[{key:\"listenAndCatch\",value:function(){var e=this;i.length<=1&&(window.addEventListener(\"error\",function(n){var r=n.message,t=n.filename,i=n.lineno,o=n.colno,s={message:r};\"\"!==t&&(s.url=t),i>0&&(s.line=i),o>0&&(s.column=o),e.sendErrorReport(s)}),window.addEventListener(\"unhandledrejection\",function(n){e.sendErrorReport({message:\"Unhandled Promise Rejection: \"+n.reason})}))}},{key:\"sendErrorReport\",value:function(e){var n,r,t;this.dryRun?\"undefined\"!=typeof console&&console.log(\"Dry run: \"+JSON.stringify(e)):this.errorRegister.isInRegisterWithinRange(e.message,500)||(this.errorRegister.addErrorToRegister(e.message),n=this.url+\"/\"+this.name,r=e,(t=new XMLHttpRequest).open(\"POST\",n),t.setRequestHeader(\"Content-Type\",\"application/json\"),t.send(JSON.stringify(r)))}}]),e}();e.SimpleErrorReport=o,Object.defineProperty(e,\"__esModule\",{value:!0})});\n\n\n\n// WEBPACK FOOTER //\n// ./node_modules/@nrk/dh-simple-error-report/dist/simple-error-report.min.js","// @flow @jsx h\n\nimport { Component, h } from 'preact'\nimport { connect } from '../../lib/provider'\nimport styles from './App.css'\nimport { debounce } from '../../lib/debounce'\nimport { bem } from '../../lib/bem'\n\nimport { InfoBox } from './InfoBox'\nimport { Trash } from './Trash'\nimport { Sea } from './Sea'\nimport { SeaOverlay } from './SeaOverlay'\nimport { SeaLight } from './SeaLight'\n\nconst PLASTIC_IN_KILO_PER_SECOND = 250\nconst MAX_FPS_COUNT = 3\nlet trackFpsCount = 0\n\ntype Props = {\n  href?: string,\n  showLink?: string,\n  linkText?: string,\n  sendErrorReport: Function,\n  trackAction: Function,\n  isXl?: boolean\n}\n\ntype State = {\n  amount: number,\n  hasIntersected: boolean,\n  prefersReducedMotion: boolean,\n  speedModifier: number,\n  breakpoint: string,\n  width: number,\n  height: number\n}\n\nclass AppComponent extends Component<Props, State> {\n  state: State = {\n    amount: 0,\n    hasIntersected: false,\n    prefersReducedMotion: false,\n    speedModifier: 2.5,\n    breakpoint: 'small',\n    width: 0,\n    height: 0\n  }\n\n  interval: any = null // IntervalID\n  observer: any = null\n  debouncedResize: ?() => void = null\n  rootEl: ?HTMLElement = null\n\n  componentDidMount (): void {\n    this.handleResize()\n    this.debouncedResize = debounce(this.handleResize, 16.667)\n    window.addEventListener('resize', this.debouncedResize)\n\n    this.handleReducedMotion()\n\n    this.observer = new IntersectionObserver(this.handleObserve, {})\n    const { rootEl } = this\n    if (rootEl) {\n      this.setState({ width: rootEl.offsetWidth, height: rootEl.offsetHeight })\n      this.observer.observe(rootEl)\n    }\n\n    this.interval = setInterval(() => {\n      const { amount } = this.state\n      this.setState({\n        amount: amount + PLASTIC_IN_KILO_PER_SECOND / this.state.speedModifier\n      })\n    }, 1000 / this.state.speedModifier)\n\n    if (this.props.isXl) {\n      this.overrideXlStyles()\n    }\n  }\n\n  overrideXlStyles = () => {\n    const allContainers = [\n      ...document.querySelectorAll('.remoterenderedcontent-reference')\n    ]\n\n    const container = allContainers.filter(c =>\n      c.querySelector(`.${styles.app}`)\n    )[0]\n\n    if (container) {\n      container.style.padding = '0'\n    }\n\n    if (this.rootEl) {\n      this.setState({\n        width: this.rootEl.offsetWidth,\n        height: this.rootEl.offsetHeight\n      })\n    }\n  }\n\n  componentWillUnmount (): void {\n    window.removeEventListener('resize', this.debouncedResize)\n    if (this.interval) {\n      clearInterval(this.interval)\n    }\n    if (this.observer) {\n      this.observer.disconnect()\n      this.observer = null\n    }\n  }\n\n  handleReducedMotion = () => {\n    const { trackAction } = this.props\n    const { matches: prefersReducedMotion } = window.matchMedia(\n      '(prefers-reduced-motion: reduce)'\n    )\n    this.setState({ prefersReducedMotion })\n    if (prefersReducedMotion) {\n      this.setState({ speedModifier: 0.5 })\n      trackAction(`PREFER_REDUCED_MOTION`)\n    }\n  }\n\n  handleFpsUpdate = (fps) => {\n    const { trackAction } = this.props\n    if (trackFpsCount <= MAX_FPS_COUNT) {\n      if (fps <= 61) {\n        trackAction('FPS', fps)\n        trackFpsCount++\n      }\n    }\n  }\n\n  handleObserve = (enteries, observer) => {\n    const { isIntersecting } = (enteries && enteries[0]) || false\n    const { hasIntersected } = this.state\n    const { trackAction } = this.props\n\n    if (isIntersecting && !hasIntersected) {\n      this.setState({ hasIntersected: true })\n      trackAction('SCROLL_IN')\n    } else if (hasIntersected) {\n      trackAction(isIntersecting ? 'SCROLL_IN' : 'SCROLL_OUT')\n    }\n  }\n\n  handleResize = () => {\n    if (!this.rootEl) return\n    this.setState({ breakpoint: getCurrentBreakpoint(this.rootEl.offsetWidth) })\n  }\n\n  render () {\n    const { href, showLink, linkText } = this.props\n    const {\n      amount,\n      hasIntersected,\n      breakpoint,\n      height,\n      width,\n      prefersReducedMotion\n    } = this.state\n    return (\n      <div\n        class={bem(styles.app, breakpoint, hasIntersected && 'has-intersected')}\n        ref={el => {\n          this.rootEl = el\n        }}\n      >\n        <Sea />\n        <Trash\n          prefersReducedMotion={prefersReducedMotion}\n          shouldMount={hasIntersected}\n          height={height}\n          width={width}\n          onFpsUpdate={this.handleFpsUpdate}\n        />\n        <SeaLight />\n        <SeaOverlay />\n        <InfoBox\n          amount={amount}\n          showLink={showLink}\n          href={href}\n          linkText={linkText}\n        />\n      </div>\n    )\n  }\n}\n\nconst App = connect()(AppComponent)\n\nexport { App }\n\nfunction getCurrentBreakpoint (width) {\n  if (width > 1600) return 'extra-large'\n  if (width > 1200) return 'large'\n  if (width > 800) return 'medium'\n  return 'small'\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/v1/components/App.js","// @flow\n\nfunction debounce (func: Function, wait: number, immediate?: boolean) {\n  let timeout\n\n  return function () {\n    const context = this\n    const args = arguments\n\n    let later = function () {\n      timeout = null\n      if (!immediate) func.apply(context, args)\n    }\n    const callNow = immediate && !timeout\n    if (timeout) clearTimeout(timeout)\n    timeout = setTimeout(later, wait)\n    if (callNow) func.apply(context, args)\n  }\n}\n\nexport { debounce }\n\n\n\n// WEBPACK FOOTER //\n// ./src/lib/debounce.js","// @flow @jsx h\nimport { h } from 'preact'\nimport { Counter } from './Counter'\nimport { bem } from '../../lib/bem'\nimport styles from './InfoBox.css'\n\ntype Props = {\n  showLink?: string,\n  linkText?: string,\n  href?: string,\n  amount: number\n}\n\nexport const InfoBox = ({ amount, showLink, href, linkText }: Props) => {\n  const amountInBottles = Math.ceil(amount * 20).toLocaleString('no')\n  const amountInFleece = Math.ceil(amount * 33).toLocaleString('no')\n\n  return (\n    <div class={styles['info-box']}>\n      <div class={styles['info-box__inner']}>\n        <span class='nrk-sr'>\n          Mens du har lest denne artikkelen har det havnet{' '}\n          {parseFloat(amount / 1000).toFixed(1)} tonn plast i havet. Det\n          tilsvarer {amountInBottles} flasker eller {amountInFleece} bleier.\n        </span>\n        <p class={styles['info-box__paragraph']} aria-hidden>\n          <span class={styles['info-box__text-line']}>\n            Mens du har lest denne artikkelen\n          </span>{' '}\n          <span class={styles['info-box__text-line']}>har det havnet</span>\n          <Counter\n            amount={parseFloat(amount / 1000).toFixed(1)}\n            afterText={' tonn'}\n          />\n          <span class={styles['info-box__big-text']}>plast i havet</span>\n        </p>\n        <p class={bem(styles['info-box__paragraph'], 'darker')} aria-hidden>\n          <span class={styles['info-box__text-line']}>\n            Det tilsvarer {amountInBottles} flasker{' '}\n          </span>\n          <span class={styles['info-box__text-line']}>\n            eller {amountInFleece} bleier.\n          </span>\n        </p>\n        {showLink &&\n          href && (\n            <a\n              class={`nrk-button ${styles['info-box__link-button']}`}\n              href={href}\n            >\n              {linkText || 'Hva kan jeg gjøre med det?'}\n              <span aria-hidden>\n                <svg\n                  xmlns='http://www.w3.org/2000/svg'\n                  viewBox='0 0 26 15'\n                  width='25'\n                >\n                  <path\n                    stroke='currentColor'\n                    fill='none'\n                    strokeLinecap='round'\n                    d='M2 7.5h22m-6-6l6 6-6 6'\n                  />\n                </svg>\n              </span>\n            </a>\n          )}\n      </div>\n    </div>\n  )\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/v1/components/InfoBox.js","// @flow @jsx h\n\nimport { h } from 'preact'\nimport styles from './Counter.css'\n\ntype Props = {\n  amount: string,\n  afterText: string\n}\n\nexport const Counter = ({ amount, afterText }: Props) => {\n  const amountInTon = String(amount).replace('.', ',')\n  return (\n    <span className={styles.counter}>\n      {amountInTon.split('').map((v, i) => (\n        <span class={v === ',' ? '' : styles.counter__number} key={v + '' + i}>\n          {v}\n        </span>\n      ))}\n      {afterText}\n    </span>\n  )\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/v1/components/Counter.js","// removed by extract-text-webpack-plugin\nmodule.exports = {\"counter\":\"dh-dh-plastic-counter-counter\",\"app--small\":\"dh-dh-plastic-counter-app--small\",\"counter__number\":\"dh-dh-plastic-counter-counter__number\"};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./src/v1/components/Counter.css\n// module id = 23\n// module chunks = 0","// removed by extract-text-webpack-plugin\nmodule.exports = {\"info-box\":\"dh-dh-plastic-counter-info-box\",\"info-box__inner\":\"dh-dh-plastic-counter-info-box__inner\",\"info-box__paragraph\":\"dh-dh-plastic-counter-info-box__paragraph\",\"info-box__paragraph--darker\":\"dh-dh-plastic-counter-info-box__paragraph--darker\",\"info-box__link-button\":\"dh-dh-plastic-counter-info-box__link-button\",\"info-box__big-text\":\"dh-dh-plastic-counter-info-box__big-text\",\"app--small\":\"dh-dh-plastic-counter-app--small\",\"info-box__text-line\":\"dh-dh-plastic-counter-info-box__text-line\"};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./src/v1/components/InfoBox.css\n// module id = 24\n// module chunks = 0","// @flow @jsx h\n\nimport { h, Component } from 'preact'\nimport { trash } from '../modules/trashController'\nimport { bem } from '../../lib/bem'\nimport styles from './Trash.css'\n\ntype Props = {\n  shouldMount: boolean,\n  prefersReducedMotion: boolean,\n  width: number,\n  height: number,\n  onFpsUpdate: Function\n}\n\ntype State = {\n  hasMounted: boolean\n}\n\nexport class Trash extends Component<Props, State> {\n  elm: HTMLDivElement\n  state = {\n    hasMounted: false\n  }\n  componentWillUpdate = (nextProps: Props) => {\n    if (!this.state.hasMounted && nextProps.shouldMount) {\n      this.setState({ hasMounted: true })\n      this.mountTrash()\n    }\n  }\n\n  mountTrash = () => {\n    const { elm } = this\n    const { width, height, onFpsUpdate } = this.props\n    trash(elm, {\n      width,\n      height,\n      onFpsUpdate\n    })\n  }\n\n  render () {\n    const { hasMounted } = this.state\n    const { prefersReducedMotion } = this.props\n\n    if (prefersReducedMotion) {\n      return (\n        <div class={styles.trash__fallback}>\n          <div class={styles['trash__fallback-top']} />\n          <div class={styles['trash__fallback-body']} />\n        </div>\n      )\n    }\n\n    return (\n      <div\n        ref={elm => (this.elm = elm)}\n        class={bem(styles.trash, hasMounted && 'active')}\n      />\n    )\n  }\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/v1/components/Trash.js","// @flow @jsx h\n\nimport {\n  Engine,\n  Render,\n  Runner,\n  Common,\n  World,\n  Bodies,\n  Body,\n  Composite\n} from 'matter-js'\n\nconst { random, choose } = Common\n\nconst bodies = [\n  {\n    width: 52,\n    height: 140,\n    base64:\n      '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'\n  },\n  {\n    width: 94,\n    height: 206,\n    base64:\n      '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'\n  },\n  {\n    width: 56,\n    height: 158,\n    base64:\n      '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'\n  },\n  {\n    width: 70,\n    height: 98,\n    base64:\n      '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'\n  },\n  {\n    width: 46,\n    height: 64,\n    base64:\n      'iVBORw0KGgoAAAANSUhEUgAAAC4AAABACAYAAABlR0UdAAAAAXNSR0IArs4c6QAAA55JREFUaAXVmsFOGzEQhj3eTRpaVc2Rc58ACRQpKkilufXWvhB9Al6hZ0DqI1BEUXPoQ1TqoaQENXBppZKsO7PZeO21HRBydid7YHdtZ/z5z9iejIF3F8PPQqjXIvL148/fyBZLcwBwJgGSg7JoPZ5AqgP56VXvHECcrgcyUcLpt8HgPJ0DJ4f97vM3MeH73W5Mc9rW0eXokF4k/UkS9Z3u63ClkOasueJpml4Nb26icq9qcj7ttMYEmis+3d6e4EzNopKvwhiA2tzb+63BTwBmuCRer6KvqDaVuJ6zFornxpXIv4KoHUU2BkJcLUzmrpK/AOjCRSW7O5TianC1Boorn+JSKP6uYoirFUe3YO8qIR9nr3gGpVcYivOfnABSi6vBlSgL2a0mBRDukdqdNTiORhdyBU+y1FX8WTLThVzBM+hocbXiL3s97vFK9nbQmyxE1eAf0IFwgWerOv7YGROjA04FwHkTUmCJqhUvRqJ9aDEyLndlrOHEVAG3R8UFmjhA2PtMBZzztl/umjQQGxz4Kq4qYbcNLsqdiUbF6spsUS1wzA5ZM5cTuARlLRwWuJjxjVfMAIsEtcBB8I1XMmm7sQUu5B1bV2l1OhabBX7c70/wVwamKnhdxPQV2UyqInc4L8KkkHp/MRz3uy82zUaPeY6ZOzy+HI2JzeSwFC8qrNlrNm7qWXliKEtxAqOYIEYeMWbuENV2xHQUx5jAmgRNqWz1q+ztnuocxXEk416E3HZMHz/6ObpfccFx96yEtF7Fcer+Yufj0t3RHR9XImPn4xhDPchVnEbWRGngZZa5k9NRvOX5WhpgtbpMIHXEdMA32m2nkWWlgZf2Ezf74IB/3Nq6RbZpA3zeLnHzmX7Z3XVO1hxwigkwqGEzQenAoRqn0Agd8Pmw3VnslaOeQq/rBsD5KE4ZLJ8+IXDvKH0Gaih7OHg1a1QDXLALZPGK6FUcp6e3cdD6CitAuds9decHD/jVCvmCpiGQ6/GCC+OsJWixpooswOIFryYYa2L0diONcx+zgRdcST4RopyV5z73gkv8/xWzUZPPGy2/iF7FT3Z2bnGb/dckcN43wN3Z/r4Tp1CdF7wA9i78RV1NNzcOX3QcBPflMhYfquu+bD8JgiMcAz9/hOIc8ivVUwjzmw4rXjmeMz9U1/Oy48sweCUfXRes2Q+ubEF3DYNXzlxMg3U9Z0sYwuAMJif+igwuyUHwJBDc1KU29SOX/CvKf2qQAQ7MvtQSAAAAAElFTkSuQmCC'\n  },\n  {\n    // fork\n    width: 18,\n    height: 110,\n    base64:\n      'iVBORw0KGgoAAAANSUhEUgAAABIAAABuCAYAAAAqLkPtAAAAAXNSR0IArs4c6QAAA2dJREFUWAntWT2LFEEQ3fXrPPU8P+5Q8BeIYGasoX/CWEEwMRJMzEz9A4KJgbEIgpFgJpcoGJgrihxyiujeeet7zdTy7K6e6WlmRZZrqO2erqpXr6q7Z4bZ0XQ6HUOeQLYgN0ZRw9wtyEfIY8h+VeP6IWQTcnuEn0sQa+/VkGMoPpgS/UXTY3xW5rf2QbFuSvTnZGzDVRugPyzjMzJeIdCKTCwjygG7xniM8bJdo+e1tRM2YB8Dce4Yf5p2BL06097aSRugn1KhjtTp9VFOSFNQBQqMYmNNVUGJp0CnJIDLSIHbgJRRAFJHBlHnWJdjtMsaxcYKpGMG0WInqXFltClwDNTKSPcJAdVZx9QpkNYopDYYoz5AuRoFRr1Tw9HhXUDPYABaYvLSSorNc6b1+k2qfYAsNV16cghAemvgZBsju7Gt0VBab0Y5oB1SPSTIHLYxsrqcjnwCo9mNrFG2AeUYbZORKS2I7isFpd6KHdcoANUwildt0sUod9biGm2TjRXQUjvePAAYRO+W1Jut7mrOTwg0FQNOsi6PINTFK3oHQfhsuwLR9pNP2QlmDupsxfgp6f+qcIxdfhDoezxbcR0e2V8qHGOXTTJ6G89WXL8j0PMKx9jlBV9b1iHfILXt2QwVCHcrUSbwO69AfJ151RNsF/bXZiA2wOQq5HUh2A7sbppv0kO5BLkPoWGu8VXwcuLsTcDwQQ4F81c9Hy6/1+yUezrXx52Ed3zqFTB+fAVdDsg1btDcIDkg17gBcoPkgFzjoYFctnNn5EYdOjW3frnU2hi5uhqgXoxc45oaufQbIFeXS+2fMHKD5Bi59Gtq5EbtVSPcAXlTa3upcIN4qbWBkJSbtgfkRmzSYufqPSA34jyA3EBzZeTWYDFSc4spqbn6uRbbjSiM+G6e7P4aRsRMgtUCJVukFmiPkax1ZlhUo2SPOGALvGpFqZXUqKjYiZFT7MSm9ogUpZZEq2VUUqM9Rk51o6n/r0bJFvE25AIvf0lqRTVKjKKl52ViU1vswYCKNuRgNVpgoPhrsrP6HcvvvdJ5KCX7qIQNsTv3UcmKFQENxqgUKGEenzV+2+aH8q6WfLr+C2g8Hn8FwkYXCvTd33exBS5APkNy7Q0U+q9xPi4M1yD3IBsQ/ln+CfISch0S/40WgP4AB/oWX2xvlAcAAAAASUVORK5CYII='\n  },\n  {\n    // sucking tube\n    width: 22,\n    height: 136,\n    base64:\n      'iVBORw0KGgoAAAANSUhEUgAAABYAAACICAYAAADj2BsIAAAAAXNSR0IArs4c6QAAAaBJREFUaAXtlSFIQ2EUhZ86EdEgFsOyRcw2Ma1YBMFmsgpGm3VgFAxGwWayiAwMlmHRNBAELRoFDUMUZb6dh+xwkDfm7lOL58HPvv/B/TY+Lpok//JJ03QS5xznFGfsRyJANIpTx+k8x4ChQvJMgHPUMcrnblHxnsgU78NiWLbUJPwGroTEGFwTkeIHLqtR6SKG39UmvBmVzkHyLCLFnah0GpYHNQkfggf7FmNoCudWRIpnuIxEpOMYvFSTcAM8EZEOY7AmIsU7XMoR6QAGD9Qk/Aie6VuaDWBwW0SKL7jMR6UbahJugZej0hUMZ4K8Zz0qXYDtNc+Id9WodBbDT12k+yFpNgThdRfpCd6XiojzvBd4WexfTZ4V75aiv7TXH47mb4mj3qTXL7Y4XICDbuwULEDwVjgFCxC8FU7BAgRvhVOwAMFb4RQsQPBWOAULELwVTsECBG+FU7AAwVvhFCxA8FY4BQsQvBVOwQIEb4VTsADBW+EULEDwVjgFCxC8FU7BAgRvhVOwAMFb4RQsQPBW/G2KG37dJzTwcfXl3bevbc3qaR0v93P/AAAAAElFTkSuQmCC'\n  }\n]\n\ntype Options = {\n  width: number,\n  height: number,\n  onFpsUpdate: Function\n}\n\nconst trash = (elm: HTMLElement, opts: Options): void => {\n  const engine = Engine.create()\n  const { width, height, onFpsUpdate } = opts\n\n  const render = Render.create({\n    element: elm,\n    engine: engine,\n    options: {\n      width,\n      height,\n      wireframes: false,\n      background: 'transparent'\n    }\n  })\n\n  Render.run(render)\n\n  const runner = Runner.create()\n  Runner.run(runner, engine)\n\n  setTimeout(() => {\n    onFpsUpdate(runner.fps)\n  }, 1000)\n\n  setInterval(() => {\n    onFpsUpdate(runner.fps)\n  }, 5000)\n\n  const world = engine.world\n  world.gravity.scale = 0\n\n  setInterval(() => {\n    const bodiesToRemove = world.bodies.filter(\n      item => item.position.x > width + 10 || item.position.y > height + 100\n    )\n    bodiesToRemove.forEach(composite => {\n      Composite.remove(world, composite)\n    })\n    addBodiesWithSprites(world, {\n      numberOfBodies: bodiesToRemove.length,\n      width,\n      height\n    })\n  }, 100)\n\n  const bodiesFromWidth = width / 7\n  const maxNumberOfBodies = 150\n  const numberOfBodies =\n    bodiesFromWidth > maxNumberOfBodies ? maxNumberOfBodies : bodiesFromWidth\n  addBodiesWithSprites(world, { numberOfBodies, width, height, fill: true })\n\n  World.add(world, [\n    Bodies.rectangle(width / 2, height + 2.5, width + 200, 5, {\n      isStatic: true,\n      render: { fillStyle: 'transparent' }\n    }),\n    Bodies.rectangle(width / 2, 22, width + 200, 5, {\n      isStatic: true,\n      render: { fillStyle: 'transparent' }\n    })\n  ])\n}\n\nfunction addBodiesWithSprites (\n  composite: World,\n  {\n    numberOfBodies,\n    width,\n    height,\n    fill\n  }: { numberOfBodies: number, width: number, height: number, fill?: boolean }\n) {\n  for (let i = 0; i < numberOfBodies; i += 1) {\n    const x = fill ? random(0, width) : -100\n    const y = random(40, height - 100)\n    const body = choose(\n      bodies.map(sprite => {\n        return addBody(sprite, { x, y })\n      })\n    )\n\n    const xVelocity = random(3, 4)\n    const yVelocity = random(-0.2, 1.5)\n\n    Body.setVelocity(body, {\n      x: xVelocity,\n      y: yVelocity\n    })\n\n    World.add(composite, body)\n  }\n}\n\nfunction addBody (sprite, { x, y }: { x: number, y: number }) {\n  return Bodies.rectangle(x, y, sprite.width / 2 / 2, sprite.height / 2 / 2, {\n    friction: 0,\n    frictionAir: 0,\n    angle: random(Math.PI * 0.01, Math.PI),\n    render: {\n      strokeStyle: '#fff',\n      sprite: {\n        texture: `data:image/png;base64,${sprite.base64}`,\n        xScale: 0.3,\n        yScale: 0.3\n      }\n    }\n  })\n}\n\nexport { trash }\n\n\n\n// WEBPACK FOOTER //\n// ./src/v1/modules/trashController.js","/**\n* matter-js 0.14.1 by @liabru 2018-01-10\n* http://brm.io/matter-js/\n* License MIT\n*/\n\n/**\n * The MIT License (MIT)\n * \n * Copyright (c) Liam Brummitt and contributors.\n * \n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n * \n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n * \n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\n(function(f){if(typeof exports===\"object\"&&typeof module!==\"undefined\"){module.exports=f()}else if(typeof define===\"function\"&&define.amd){define([],f)}else{var g;if(typeof window!==\"undefined\"){g=window}else if(typeof global!==\"undefined\"){g=global}else if(typeof self!==\"undefined\"){g=self}else{g=this}g.Matter = f()}})(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require==\"function\"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error(\"Cannot find module '\"+o+\"'\");throw f.code=\"MODULE_NOT_FOUND\",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require==\"function\"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(_dereq_,module,exports){\n/**\n* The `Matter.Body` module contains methods for creating and manipulating body models.\n* A `Matter.Body` is a rigid body that can be simulated by a `Matter.Engine`.\n* Factories for commonly used body configurations (such as rectangles, circles and other polygons) can be found in the module `Matter.Bodies`.\n*\n* See the included usage [examples](https://github.com/liabru/matter-js/tree/master/examples).\n\n* @class Body\n*/\n\nvar Body = {};\n\nmodule.exports = Body;\n\nvar Vertices = _dereq_('../geometry/Vertices');\nvar Vector = _dereq_('../geometry/Vector');\nvar Sleeping = _dereq_('../core/Sleeping');\nvar Render = _dereq_('../render/Render');\nvar Common = _dereq_('../core/Common');\nvar Bounds = _dereq_('../geometry/Bounds');\nvar Axes = _dereq_('../geometry/Axes');\n\n(function() {\n\n    Body._inertiaScale = 4;\n    Body._nextCollidingGroupId = 1;\n    Body._nextNonCollidingGroupId = -1;\n    Body._nextCategory = 0x0001;\n\n    /**\n     * Creates a new rigid body model. The options parameter is an object that specifies any properties you wish to override the defaults.\n     * All properties have default values, and many are pre-calculated automatically based on other properties.\n     * Vertices must be specified in clockwise order.\n     * See the properties section below for detailed information on what you can pass via the `options` object.\n     * @method create\n     * @param {} options\n     * @return {body} body\n     */\n    Body.create = function(options) {\n        var defaults = {\n            id: Common.nextId(),\n            type: 'body',\n            label: 'Body',\n            parts: [],\n            plugin: {},\n            angle: 0,\n            vertices: Vertices.fromPath('L 0 0 L 40 0 L 40 40 L 0 40'),\n            position: { x: 0, y: 0 },\n            force: { x: 0, y: 0 },\n            torque: 0,\n            positionImpulse: { x: 0, y: 0 },\n            constraintImpulse: { x: 0, y: 0, angle: 0 },\n            totalContacts: 0,\n            speed: 0,\n            angularSpeed: 0,\n            velocity: { x: 0, y: 0 },\n            angularVelocity: 0,\n            isSensor: false,\n            isStatic: false,\n            isSleeping: false,\n            motion: 0,\n            sleepThreshold: 60,\n            density: 0.001,\n            restitution: 0,\n            friction: 0.1,\n            frictionStatic: 0.5,\n            frictionAir: 0.01,\n            collisionFilter: {\n                category: 0x0001,\n                mask: 0xFFFFFFFF,\n                group: 0\n            },\n            slop: 0.05,\n            timeScale: 1,\n            render: {\n                visible: true,\n                opacity: 1,\n                sprite: {\n                    xScale: 1,\n                    yScale: 1,\n                    xOffset: 0,\n                    yOffset: 0\n                },\n                lineWidth: 0\n            }\n        };\n\n        var body = Common.extend(defaults, options);\n\n        _initProperties(body, options);\n\n        return body;\n    };\n\n    /**\n     * Returns the next unique group index for which bodies will collide.\n     * If `isNonColliding` is `true`, returns the next unique group index for which bodies will _not_ collide.\n     * See `body.collisionFilter` for more information.\n     * @method nextGroup\n     * @param {bool} [isNonColliding=false]\n     * @return {Number} Unique group index\n     */\n    Body.nextGroup = function(isNonColliding) {\n        if (isNonColliding)\n            return Body._nextNonCollidingGroupId--;\n\n        return Body._nextCollidingGroupId++;\n    };\n\n    /**\n     * Returns the next unique category bitfield (starting after the initial default category `0x0001`).\n     * There are 32 available. See `body.collisionFilter` for more information.\n     * @method nextCategory\n     * @return {Number} Unique category bitfield\n     */\n    Body.nextCategory = function() {\n        Body._nextCategory = Body._nextCategory << 1;\n        return Body._nextCategory;\n    };\n\n    /**\n     * Initialises body properties.\n     * @method _initProperties\n     * @private\n     * @param {body} body\n     * @param {} [options]\n     */\n    var _initProperties = function(body, options) {\n        options = options || {};\n\n        // init required properties (order is important)\n        Body.set(body, {\n            bounds: body.bounds || Bounds.create(body.vertices),\n            positionPrev: body.positionPrev || Vector.clone(body.position),\n            anglePrev: body.anglePrev || body.angle,\n            vertices: body.vertices,\n            parts: body.parts || [body],\n            isStatic: body.isStatic,\n            isSleeping: body.isSleeping,\n            parent: body.parent || body\n        });\n\n        Vertices.rotate(body.vertices, body.angle, body.position);\n        Axes.rotate(body.axes, body.angle);\n        Bounds.update(body.bounds, body.vertices, body.velocity);\n\n        // allow options to override the automatically calculated properties\n        Body.set(body, {\n            axes: options.axes || body.axes,\n            area: options.area || body.area,\n            mass: options.mass || body.mass,\n            inertia: options.inertia || body.inertia\n        });\n\n        // render properties\n        var defaultFillStyle = (body.isStatic ? '#2e2b44' : Common.choose(['#006BA6', '#0496FF', '#FFBC42', '#D81159', '#8F2D56'])),\n            defaultStrokeStyle = '#000';\n        body.render.fillStyle = body.render.fillStyle || defaultFillStyle;\n        body.render.strokeStyle = body.render.strokeStyle || defaultStrokeStyle;\n        body.render.sprite.xOffset += -(body.bounds.min.x - body.position.x) / (body.bounds.max.x - body.bounds.min.x);\n        body.render.sprite.yOffset += -(body.bounds.min.y - body.position.y) / (body.bounds.max.y - body.bounds.min.y);\n    };\n\n    /**\n     * Given a property and a value (or map of), sets the property(s) on the body, using the appropriate setter functions if they exist.\n     * Prefer to use the actual setter functions in performance critical situations.\n     * @method set\n     * @param {body} body\n     * @param {} settings A property name (or map of properties and values) to set on the body.\n     * @param {} value The value to set if `settings` is a single property name.\n     */\n    Body.set = function(body, settings, value) {\n        var property;\n\n        if (typeof settings === 'string') {\n            property = settings;\n            settings = {};\n            settings[property] = value;\n        }\n\n        for (property in settings) {\n            value = settings[property];\n\n            if (!settings.hasOwnProperty(property))\n                continue;\n\n            switch (property) {\n\n            case 'isStatic':\n                Body.setStatic(body, value);\n                break;\n            case 'isSleeping':\n                Sleeping.set(body, value);\n                break;\n            case 'mass':\n                Body.setMass(body, value);\n                break;\n            case 'density':\n                Body.setDensity(body, value);\n                break;\n            case 'inertia':\n                Body.setInertia(body, value);\n                break;\n            case 'vertices':\n                Body.setVertices(body, value);\n                break;\n            case 'position':\n                Body.setPosition(body, value);\n                break;\n            case 'angle':\n                Body.setAngle(body, value);\n                break;\n            case 'velocity':\n                Body.setVelocity(body, value);\n                break;\n            case 'angularVelocity':\n                Body.setAngularVelocity(body, value);\n                break;\n            case 'parts':\n                Body.setParts(body, value);\n                break;\n            default:\n                body[property] = value;\n\n            }\n        }\n    };\n\n    /**\n     * Sets the body as static, including isStatic flag and setting mass and inertia to Infinity.\n     * @method setStatic\n     * @param {body} body\n     * @param {bool} isStatic\n     */\n    Body.setStatic = function(body, isStatic) {\n        for (var i = 0; i < body.parts.length; i++) {\n            var part = body.parts[i];\n            part.isStatic = isStatic;\n\n            if (isStatic) {\n                part._original = {\n                    restitution: part.restitution,\n                    friction: part.friction,\n                    mass: part.mass,\n                    inertia: part.inertia,\n                    density: part.density,\n                    inverseMass: part.inverseMass,\n                    inverseInertia: part.inverseInertia\n                };\n\n                part.restitution = 0;\n                part.friction = 1;\n                part.mass = part.inertia = part.density = Infinity;\n                part.inverseMass = part.inverseInertia = 0;\n\n                part.positionPrev.x = part.position.x;\n                part.positionPrev.y = part.position.y;\n                part.anglePrev = part.angle;\n                part.angularVelocity = 0;\n                part.speed = 0;\n                part.angularSpeed = 0;\n                part.motion = 0;\n            } else if (part._original) {\n                part.restitution = part._original.restitution;\n                part.friction = part._original.friction;\n                part.mass = part._original.mass;\n                part.inertia = part._original.inertia;\n                part.density = part._original.density;\n                part.inverseMass = part._original.inverseMass;\n                part.inverseInertia = part._original.inverseInertia;\n\n                delete part._original;\n            }\n        }\n    };\n\n    /**\n     * Sets the mass of the body. Inverse mass, density and inertia are automatically updated to reflect the change.\n     * @method setMass\n     * @param {body} body\n     * @param {number} mass\n     */\n    Body.setMass = function(body, mass) {\n        var moment = body.inertia / (body.mass / 6);\n        body.inertia = moment * (mass / 6);\n        body.inverseInertia = 1 / body.inertia;\n\n        body.mass = mass;\n        body.inverseMass = 1 / body.mass;\n        body.density = body.mass / body.area;\n    };\n\n    /**\n     * Sets the density of the body. Mass and inertia are automatically updated to reflect the change.\n     * @method setDensity\n     * @param {body} body\n     * @param {number} density\n     */\n    Body.setDensity = function(body, density) {\n        Body.setMass(body, density * body.area);\n        body.density = density;\n    };\n\n    /**\n     * Sets the moment of inertia (i.e. second moment of area) of the body of the body. \n     * Inverse inertia is automatically updated to reflect the change. Mass is not changed.\n     * @method setInertia\n     * @param {body} body\n     * @param {number} inertia\n     */\n    Body.setInertia = function(body, inertia) {\n        body.inertia = inertia;\n        body.inverseInertia = 1 / body.inertia;\n    };\n\n    /**\n     * Sets the body's vertices and updates body properties accordingly, including inertia, area and mass (with respect to `body.density`).\n     * Vertices will be automatically transformed to be orientated around their centre of mass as the origin.\n     * They are then automatically translated to world space based on `body.position`.\n     *\n     * The `vertices` argument should be passed as an array of `Matter.Vector` points (or a `Matter.Vertices` array).\n     * Vertices must form a convex hull, concave hulls are not supported.\n     *\n     * @method setVertices\n     * @param {body} body\n     * @param {vector[]} vertices\n     */\n    Body.setVertices = function(body, vertices) {\n        // change vertices\n        if (vertices[0].body === body) {\n            body.vertices = vertices;\n        } else {\n            body.vertices = Vertices.create(vertices, body);\n        }\n\n        // update properties\n        body.axes = Axes.fromVertices(body.vertices);\n        body.area = Vertices.area(body.vertices);\n        Body.setMass(body, body.density * body.area);\n\n        // orient vertices around the centre of mass at origin (0, 0)\n        var centre = Vertices.centre(body.vertices);\n        Vertices.translate(body.vertices, centre, -1);\n\n        // update inertia while vertices are at origin (0, 0)\n        Body.setInertia(body, Body._inertiaScale * Vertices.inertia(body.vertices, body.mass));\n\n        // update geometry\n        Vertices.translate(body.vertices, body.position);\n        Bounds.update(body.bounds, body.vertices, body.velocity);\n    };\n\n    /**\n     * Sets the parts of the `body` and updates mass, inertia and centroid.\n     * Each part will have its parent set to `body`.\n     * By default the convex hull will be automatically computed and set on `body`, unless `autoHull` is set to `false.`\n     * Note that this method will ensure that the first part in `body.parts` will always be the `body`.\n     * @method setParts\n     * @param {body} body\n     * @param [body] parts\n     * @param {bool} [autoHull=true]\n     */\n    Body.setParts = function(body, parts, autoHull) {\n        var i;\n\n        // add all the parts, ensuring that the first part is always the parent body\n        parts = parts.slice(0);\n        body.parts.length = 0;\n        body.parts.push(body);\n        body.parent = body;\n\n        for (i = 0; i < parts.length; i++) {\n            var part = parts[i];\n            if (part !== body) {\n                part.parent = body;\n                body.parts.push(part);\n            }\n        }\n\n        if (body.parts.length === 1)\n            return;\n\n        autoHull = typeof autoHull !== 'undefined' ? autoHull : true;\n\n        // find the convex hull of all parts to set on the parent body\n        if (autoHull) {\n            var vertices = [];\n            for (i = 0; i < parts.length; i++) {\n                vertices = vertices.concat(parts[i].vertices);\n            }\n\n            Vertices.clockwiseSort(vertices);\n\n            var hull = Vertices.hull(vertices),\n                hullCentre = Vertices.centre(hull);\n\n            Body.setVertices(body, hull);\n            Vertices.translate(body.vertices, hullCentre);\n        }\n\n        // sum the properties of all compound parts of the parent body\n        var total = Body._totalProperties(body);\n\n        body.area = total.area;\n        body.parent = body;\n        body.position.x = total.centre.x;\n        body.position.y = total.centre.y;\n        body.positionPrev.x = total.centre.x;\n        body.positionPrev.y = total.centre.y;\n\n        Body.setMass(body, total.mass);\n        Body.setInertia(body, total.inertia);\n        Body.setPosition(body, total.centre);\n    };\n\n    /**\n     * Sets the position of the body instantly. Velocity, angle, force etc. are unchanged.\n     * @method setPosition\n     * @param {body} body\n     * @param {vector} position\n     */\n    Body.setPosition = function(body, position) {\n        var delta = Vector.sub(position, body.position);\n        body.positionPrev.x += delta.x;\n        body.positionPrev.y += delta.y;\n\n        for (var i = 0; i < body.parts.length; i++) {\n            var part = body.parts[i];\n            part.position.x += delta.x;\n            part.position.y += delta.y;\n            Vertices.translate(part.vertices, delta);\n            Bounds.update(part.bounds, part.vertices, body.velocity);\n        }\n    };\n\n    /**\n     * Sets the angle of the body instantly. Angular velocity, position, force etc. are unchanged.\n     * @method setAngle\n     * @param {body} body\n     * @param {number} angle\n     */\n    Body.setAngle = function(body, angle) {\n        var delta = angle - body.angle;\n        body.anglePrev += delta;\n\n        for (var i = 0; i < body.parts.length; i++) {\n            var part = body.parts[i];\n            part.angle += delta;\n            Vertices.rotate(part.vertices, delta, body.position);\n            Axes.rotate(part.axes, delta);\n            Bounds.update(part.bounds, part.vertices, body.velocity);\n            if (i > 0) {\n                Vector.rotateAbout(part.position, delta, body.position, part.position);\n            }\n        }\n    };\n\n    /**\n     * Sets the linear velocity of the body instantly. Position, angle, force etc. are unchanged. See also `Body.applyForce`.\n     * @method setVelocity\n     * @param {body} body\n     * @param {vector} velocity\n     */\n    Body.setVelocity = function(body, velocity) {\n        body.positionPrev.x = body.position.x - velocity.x;\n        body.positionPrev.y = body.position.y - velocity.y;\n        body.velocity.x = velocity.x;\n        body.velocity.y = velocity.y;\n        body.speed = Vector.magnitude(body.velocity);\n    };\n\n    /**\n     * Sets the angular velocity of the body instantly. Position, angle, force etc. are unchanged. See also `Body.applyForce`.\n     * @method setAngularVelocity\n     * @param {body} body\n     * @param {number} velocity\n     */\n    Body.setAngularVelocity = function(body, velocity) {\n        body.anglePrev = body.angle - velocity;\n        body.angularVelocity = velocity;\n        body.angularSpeed = Math.abs(body.angularVelocity);\n    };\n\n    /**\n     * Moves a body by a given vector relative to its current position, without imparting any velocity.\n     * @method translate\n     * @param {body} body\n     * @param {vector} translation\n     */\n    Body.translate = function(body, translation) {\n        Body.setPosition(body, Vector.add(body.position, translation));\n    };\n\n    /**\n     * Rotates a body by a given angle relative to its current angle, without imparting any angular velocity.\n     * @method rotate\n     * @param {body} body\n     * @param {number} rotation\n     * @param {vector} [point]\n     */\n    Body.rotate = function(body, rotation, point) {\n        if (!point) {\n            Body.setAngle(body, body.angle + rotation);\n        } else {\n            var cos = Math.cos(rotation),\n                sin = Math.sin(rotation),\n                dx = body.position.x - point.x,\n                dy = body.position.y - point.y;\n                \n            Body.setPosition(body, {\n                x: point.x + (dx * cos - dy * sin),\n                y: point.y + (dx * sin + dy * cos)\n            });\n\n            Body.setAngle(body, body.angle + rotation);\n        }\n    };\n\n    /**\n     * Scales the body, including updating physical properties (mass, area, axes, inertia), from a world-space point (default is body centre).\n     * @method scale\n     * @param {body} body\n     * @param {number} scaleX\n     * @param {number} scaleY\n     * @param {vector} [point]\n     */\n    Body.scale = function(body, scaleX, scaleY, point) {\n        var totalArea = 0,\n            totalInertia = 0;\n\n        point = point || body.position;\n\n        for (var i = 0; i < body.parts.length; i++) {\n            var part = body.parts[i];\n\n            // scale vertices\n            Vertices.scale(part.vertices, scaleX, scaleY, point);\n\n            // update properties\n            part.axes = Axes.fromVertices(part.vertices);\n            part.area = Vertices.area(part.vertices);\n            Body.setMass(part, body.density * part.area);\n\n            // update inertia (requires vertices to be at origin)\n            Vertices.translate(part.vertices, { x: -part.position.x, y: -part.position.y });\n            Body.setInertia(part, Body._inertiaScale * Vertices.inertia(part.vertices, part.mass));\n            Vertices.translate(part.vertices, { x: part.position.x, y: part.position.y });\n\n            if (i > 0) {\n                totalArea += part.area;\n                totalInertia += part.inertia;\n            }\n\n            // scale position\n            part.position.x = point.x + (part.position.x - point.x) * scaleX;\n            part.position.y = point.y + (part.position.y - point.y) * scaleY;\n\n            // update bounds\n            Bounds.update(part.bounds, part.vertices, body.velocity);\n        }\n\n        // handle parent body\n        if (body.parts.length > 1) {\n            body.area = totalArea;\n\n            if (!body.isStatic) {\n                Body.setMass(body, body.density * totalArea);\n                Body.setInertia(body, totalInertia);\n            }\n        }\n\n        // handle circles\n        if (body.circleRadius) { \n            if (scaleX === scaleY) {\n                body.circleRadius *= scaleX;\n            } else {\n                // body is no longer a circle\n                body.circleRadius = null;\n            }\n        }\n    };\n\n    /**\n     * Performs a simulation step for the given `body`, including updating position and angle using Verlet integration.\n     * @method update\n     * @param {body} body\n     * @param {number} deltaTime\n     * @param {number} timeScale\n     * @param {number} correction\n     */\n    Body.update = function(body, deltaTime, timeScale, correction) {\n        var deltaTimeSquared = Math.pow(deltaTime * timeScale * body.timeScale, 2);\n\n        // from the previous step\n        var frictionAir = 1 - body.frictionAir * timeScale * body.timeScale,\n            velocityPrevX = body.position.x - body.positionPrev.x,\n            velocityPrevY = body.position.y - body.positionPrev.y;\n\n        // update velocity with Verlet integration\n        body.velocity.x = (velocityPrevX * frictionAir * correction) + (body.force.x / body.mass) * deltaTimeSquared;\n        body.velocity.y = (velocityPrevY * frictionAir * correction) + (body.force.y / body.mass) * deltaTimeSquared;\n\n        body.positionPrev.x = body.position.x;\n        body.positionPrev.y = body.position.y;\n        body.position.x += body.velocity.x;\n        body.position.y += body.velocity.y;\n\n        // update angular velocity with Verlet integration\n        body.angularVelocity = ((body.angle - body.anglePrev) * frictionAir * correction) + (body.torque / body.inertia) * deltaTimeSquared;\n        body.anglePrev = body.angle;\n        body.angle += body.angularVelocity;\n\n        // track speed and acceleration\n        body.speed = Vector.magnitude(body.velocity);\n        body.angularSpeed = Math.abs(body.angularVelocity);\n\n        // transform the body geometry\n        for (var i = 0; i < body.parts.length; i++) {\n            var part = body.parts[i];\n\n            Vertices.translate(part.vertices, body.velocity);\n            \n            if (i > 0) {\n                part.position.x += body.velocity.x;\n                part.position.y += body.velocity.y;\n            }\n\n            if (body.angularVelocity !== 0) {\n                Vertices.rotate(part.vertices, body.angularVelocity, body.position);\n                Axes.rotate(part.axes, body.angularVelocity);\n                if (i > 0) {\n                    Vector.rotateAbout(part.position, body.angularVelocity, body.position, part.position);\n                }\n            }\n\n            Bounds.update(part.bounds, part.vertices, body.velocity);\n        }\n    };\n\n    /**\n     * Applies a force to a body from a given world-space position, including resulting torque.\n     * @method applyForce\n     * @param {body} body\n     * @param {vector} position\n     * @param {vector} force\n     */\n    Body.applyForce = function(body, position, force) {\n        body.force.x += force.x;\n        body.force.y += force.y;\n        var offset = { x: position.x - body.position.x, y: position.y - body.position.y };\n        body.torque += offset.x * force.y - offset.y * force.x;\n    };\n\n    /**\n     * Returns the sums of the properties of all compound parts of the parent body.\n     * @method _totalProperties\n     * @private\n     * @param {body} body\n     * @return {}\n     */\n    Body._totalProperties = function(body) {\n        // from equations at:\n        // https://ecourses.ou.edu/cgi-bin/ebook.cgi?doc=&topic=st&chap_sec=07.2&page=theory\n        // http://output.to/sideway/default.asp?qno=121100087\n\n        var properties = {\n            mass: 0,\n            area: 0,\n            inertia: 0,\n            centre: { x: 0, y: 0 }\n        };\n\n        // sum the properties of all compound parts of the parent body\n        for (var i = body.parts.length === 1 ? 0 : 1; i < body.parts.length; i++) {\n            var part = body.parts[i],\n                mass = part.mass !== Infinity ? part.mass : 1;\n\n            properties.mass += mass;\n            properties.area += part.area;\n            properties.inertia += part.inertia;\n            properties.centre = Vector.add(properties.centre, Vector.mult(part.position, mass));\n        }\n\n        properties.centre = Vector.div(properties.centre, properties.mass);\n\n        return properties;\n    };\n\n    /*\n    *\n    *  Events Documentation\n    *\n    */\n\n    /**\n    * Fired when a body starts sleeping (where `this` is the body).\n    *\n    * @event sleepStart\n    * @this {body} The body that has started sleeping\n    * @param {} event An event object\n    * @param {} event.source The source object of the event\n    * @param {} event.name The name of the event\n    */\n\n    /**\n    * Fired when a body ends sleeping (where `this` is the body).\n    *\n    * @event sleepEnd\n    * @this {body} The body that has ended sleeping\n    * @param {} event An event object\n    * @param {} event.source The source object of the event\n    * @param {} event.name The name of the event\n    */\n\n    /*\n    *\n    *  Properties Documentation\n    *\n    */\n\n    /**\n     * An integer `Number` uniquely identifying number generated in `Body.create` by `Common.nextId`.\n     *\n     * @property id\n     * @type number\n     */\n\n    /**\n     * A `String` denoting the type of object.\n     *\n     * @property type\n     * @type string\n     * @default \"body\"\n     * @readOnly\n     */\n\n    /**\n     * An arbitrary `String` name to help the user identify and manage bodies.\n     *\n     * @property label\n     * @type string\n     * @default \"Body\"\n     */\n\n    /**\n     * An array of bodies that make up this body. \n     * The first body in the array must always be a self reference to the current body instance.\n     * All bodies in the `parts` array together form a single rigid compound body.\n     * Parts are allowed to overlap, have gaps or holes or even form concave bodies.\n     * Parts themselves should never be added to a `World`, only the parent body should be.\n     * Use `Body.setParts` when setting parts to ensure correct updates of all properties.\n     *\n     * @property parts\n     * @type body[]\n     */\n\n    /**\n     * An object reserved for storing plugin-specific properties.\n     *\n     * @property plugin\n     * @type {}\n     */\n\n    /**\n     * A self reference if the body is _not_ a part of another body.\n     * Otherwise this is a reference to the body that this is a part of.\n     * See `body.parts`.\n     *\n     * @property parent\n     * @type body\n     */\n\n    /**\n     * A `Number` specifying the angle of the body, in radians.\n     *\n     * @property angle\n     * @type number\n     * @default 0\n     */\n\n    /**\n     * An array of `Vector` objects that specify the convex hull of the rigid body.\n     * These should be provided about the origin `(0, 0)`. E.g.\n     *\n     *     [{ x: 0, y: 0 }, { x: 25, y: 50 }, { x: 50, y: 0 }]\n     *\n     * When passed via `Body.create`, the vertices are translated relative to `body.position` (i.e. world-space, and constantly updated by `Body.update` during simulation).\n     * The `Vector` objects are also augmented with additional properties required for efficient collision detection. \n     *\n     * Other properties such as `inertia` and `bounds` are automatically calculated from the passed vertices (unless provided via `options`).\n     * Concave hulls are not currently supported. The module `Matter.Vertices` contains useful methods for working with vertices.\n     *\n     * @property vertices\n     * @type vector[]\n     */\n\n    /**\n     * A `Vector` that specifies the current world-space position of the body.\n     *\n     * @property position\n     * @type vector\n     * @default { x: 0, y: 0 }\n     */\n\n    /**\n     * A `Vector` that specifies the force to apply in the current step. It is zeroed after every `Body.update`. See also `Body.applyForce`.\n     *\n     * @property force\n     * @type vector\n     * @default { x: 0, y: 0 }\n     */\n\n    /**\n     * A `Number` that specifies the torque (turning force) to apply in the current step. It is zeroed after every `Body.update`.\n     *\n     * @property torque\n     * @type number\n     * @default 0\n     */\n\n    /**\n     * A `Number` that _measures_ the current speed of the body after the last `Body.update`. It is read-only and always positive (it's the magnitude of `body.velocity`).\n     *\n     * @readOnly\n     * @property speed\n     * @type number\n     * @default 0\n     */\n\n    /**\n     * A `Number` that _measures_ the current angular speed of the body after the last `Body.update`. It is read-only and always positive (it's the magnitude of `body.angularVelocity`).\n     *\n     * @readOnly\n     * @property angularSpeed\n     * @type number\n     * @default 0\n     */\n\n    /**\n     * A `Vector` that _measures_ the current velocity of the body after the last `Body.update`. It is read-only. \n     * If you need to modify a body's velocity directly, you should either apply a force or simply change the body's `position` (as the engine uses position-Verlet integration).\n     *\n     * @readOnly\n     * @property velocity\n     * @type vector\n     * @default { x: 0, y: 0 }\n     */\n\n    /**\n     * A `Number` that _measures_ the current angular velocity of the body after the last `Body.update`. It is read-only. \n     * If you need to modify a body's angular velocity directly, you should apply a torque or simply change the body's `angle` (as the engine uses position-Verlet integration).\n     *\n     * @readOnly\n     * @property angularVelocity\n     * @type number\n     * @default 0\n     */\n\n    /**\n     * A flag that indicates whether a body is considered static. A static body can never change position or angle and is completely fixed.\n     * If you need to set a body as static after its creation, you should use `Body.setStatic` as this requires more than just setting this flag.\n     *\n     * @property isStatic\n     * @type boolean\n     * @default false\n     */\n\n    /**\n     * A flag that indicates whether a body is a sensor. Sensor triggers collision events, but doesn't react with colliding body physically.\n     *\n     * @property isSensor\n     * @type boolean\n     * @default false\n     */\n\n    /**\n     * A flag that indicates whether the body is considered sleeping. A sleeping body acts similar to a static body, except it is only temporary and can be awoken.\n     * If you need to set a body as sleeping, you should use `Sleeping.set` as this requires more than just setting this flag.\n     *\n     * @property isSleeping\n     * @type boolean\n     * @default false\n     */\n\n    /**\n     * A `Number` that _measures_ the amount of movement a body currently has (a combination of `speed` and `angularSpeed`). It is read-only and always positive.\n     * It is used and updated by the `Matter.Sleeping` module during simulation to decide if a body has come to rest.\n     *\n     * @readOnly\n     * @property motion\n     * @type number\n     * @default 0\n     */\n\n    /**\n     * A `Number` that defines the number of updates in which this body must have near-zero velocity before it is set as sleeping by the `Matter.Sleeping` module (if sleeping is enabled by the engine).\n     *\n     * @property sleepThreshold\n     * @type number\n     * @default 60\n     */\n\n    /**\n     * A `Number` that defines the density of the body, that is its mass per unit area.\n     * If you pass the density via `Body.create` the `mass` property is automatically calculated for you based on the size (area) of the object.\n     * This is generally preferable to simply setting mass and allows for more intuitive definition of materials (e.g. rock has a higher density than wood).\n     *\n     * @property density\n     * @type number\n     * @default 0.001\n     */\n\n    /**\n     * A `Number` that defines the mass of the body, although it may be more appropriate to specify the `density` property instead.\n     * If you modify this value, you must also modify the `body.inverseMass` property (`1 / mass`).\n     *\n     * @property mass\n     * @type number\n     */\n\n    /**\n     * A `Number` that defines the inverse mass of the body (`1 / mass`).\n     * If you modify this value, you must also modify the `body.mass` property.\n     *\n     * @property inverseMass\n     * @type number\n     */\n\n    /**\n     * A `Number` that defines the moment of inertia (i.e. second moment of area) of the body.\n     * It is automatically calculated from the given convex hull (`vertices` array) and density in `Body.create`.\n     * If you modify this value, you must also modify the `body.inverseInertia` property (`1 / inertia`).\n     *\n     * @property inertia\n     * @type number\n     */\n\n    /**\n     * A `Number` that defines the inverse moment of inertia of the body (`1 / inertia`).\n     * If you modify this value, you must also modify the `body.inertia` property.\n     *\n     * @property inverseInertia\n     * @type number\n     */\n\n    /**\n     * A `Number` that defines the restitution (elasticity) of the body. The value is always positive and is in the range `(0, 1)`.\n     * A value of `0` means collisions may be perfectly inelastic and no bouncing may occur. \n     * A value of `0.8` means the body may bounce back with approximately 80% of its kinetic energy.\n     * Note that collision response is based on _pairs_ of bodies, and that `restitution` values are _combined_ with the following formula:\n     *\n     *     Math.max(bodyA.restitution, bodyB.restitution)\n     *\n     * @property restitution\n     * @type number\n     * @default 0\n     */\n\n    /**\n     * A `Number` that defines the friction of the body. The value is always positive and is in the range `(0, 1)`.\n     * A value of `0` means that the body may slide indefinitely.\n     * A value of `1` means the body may come to a stop almost instantly after a force is applied.\n     *\n     * The effects of the value may be non-linear. \n     * High values may be unstable depending on the body.\n     * The engine uses a Coulomb friction model including static and kinetic friction.\n     * Note that collision response is based on _pairs_ of bodies, and that `friction` values are _combined_ with the following formula:\n     *\n     *     Math.min(bodyA.friction, bodyB.friction)\n     *\n     * @property friction\n     * @type number\n     * @default 0.1\n     */\n\n    /**\n     * A `Number` that defines the static friction of the body (in the Coulomb friction model). \n     * A value of `0` means the body will never 'stick' when it is nearly stationary and only dynamic `friction` is used.\n     * The higher the value (e.g. `10`), the more force it will take to initially get the body moving when nearly stationary.\n     * This value is multiplied with the `friction` property to make it easier to change `friction` and maintain an appropriate amount of static friction.\n     *\n     * @property frictionStatic\n     * @type number\n     * @default 0.5\n     */\n\n    /**\n     * A `Number` that defines the air friction of the body (air resistance). \n     * A value of `0` means the body will never slow as it moves through space.\n     * The higher the value, the faster a body slows when moving through space.\n     * The effects of the value are non-linear. \n     *\n     * @property frictionAir\n     * @type number\n     * @default 0.01\n     */\n\n    /**\n     * An `Object` that specifies the collision filtering properties of this body.\n     *\n     * Collisions between two bodies will obey the following rules:\n     * - If the two bodies have the same non-zero value of `collisionFilter.group`,\n     *   they will always collide if the value is positive, and they will never collide\n     *   if the value is negative.\n     * - If the two bodies have different values of `collisionFilter.group` or if one\n     *   (or both) of the bodies has a value of 0, then the category/mask rules apply as follows:\n     *\n     * Each body belongs to a collision category, given by `collisionFilter.category`. This\n     * value is used as a bit field and the category should have only one bit set, meaning that\n     * the value of this property is a power of two in the range [1, 2^31]. Thus, there are 32\n     * different collision categories available.\n     *\n     * Each body also defines a collision bitmask, given by `collisionFilter.mask` which specifies\n     * the categories it collides with (the value is the bitwise AND value of all these categories).\n     *\n     * Using the category/mask rules, two bodies `A` and `B` collide if each includes the other's\n     * category in its mask, i.e. `(categoryA & maskB) !== 0` and `(categoryB & maskA) !== 0`\n     * are both true.\n     *\n     * @property collisionFilter\n     * @type object\n     */\n\n    /**\n     * An Integer `Number`, that specifies the collision group this body belongs to.\n     * See `body.collisionFilter` for more information.\n     *\n     * @property collisionFilter.group\n     * @type object\n     * @default 0\n     */\n\n    /**\n     * A bit field that specifies the collision category this body belongs to.\n     * The category value should have only one bit set, for example `0x0001`.\n     * This means there are up to 32 unique collision categories available.\n     * See `body.collisionFilter` for more information.\n     *\n     * @property collisionFilter.category\n     * @type object\n     * @default 1\n     */\n\n    /**\n     * A bit mask that specifies the collision categories this body may collide with.\n     * See `body.collisionFilter` for more information.\n     *\n     * @property collisionFilter.mask\n     * @type object\n     * @default -1\n     */\n\n    /**\n     * A `Number` that specifies a tolerance on how far a body is allowed to 'sink' or rotate into other bodies.\n     * Avoid changing this value unless you understand the purpose of `slop` in physics engines.\n     * The default should generally suffice, although very large bodies may require larger values for stable stacking.\n     *\n     * @property slop\n     * @type number\n     * @default 0.05\n     */\n\n    /**\n     * A `Number` that allows per-body time scaling, e.g. a force-field where bodies inside are in slow-motion, while others are at full speed.\n     *\n     * @property timeScale\n     * @type number\n     * @default 1\n     */\n\n    /**\n     * An `Object` that defines the rendering properties to be consumed by the module `Matter.Render`.\n     *\n     * @property render\n     * @type object\n     */\n\n    /**\n     * A flag that indicates if the body should be rendered.\n     *\n     * @property render.visible\n     * @type boolean\n     * @default true\n     */\n\n    /**\n     * Sets the opacity to use when rendering.\n     *\n     * @property render.opacity\n     * @type number\n     * @default 1\n    */\n\n    /**\n     * An `Object` that defines the sprite properties to use when rendering, if any.\n     *\n     * @property render.sprite\n     * @type object\n     */\n\n    /**\n     * An `String` that defines the path to the image to use as the sprite texture, if any.\n     *\n     * @property render.sprite.texture\n     * @type string\n     */\n     \n    /**\n     * A `Number` that defines the scaling in the x-axis for the sprite, if any.\n     *\n     * @property render.sprite.xScale\n     * @type number\n     * @default 1\n     */\n\n    /**\n     * A `Number` that defines the scaling in the y-axis for the sprite, if any.\n     *\n     * @property render.sprite.yScale\n     * @type number\n     * @default 1\n     */\n\n     /**\n      * A `Number` that defines the offset in the x-axis for the sprite (normalised by texture width).\n      *\n      * @property render.sprite.xOffset\n      * @type number\n      * @default 0\n      */\n\n     /**\n      * A `Number` that defines the offset in the y-axis for the sprite (normalised by texture height).\n      *\n      * @property render.sprite.yOffset\n      * @type number\n      * @default 0\n      */\n\n    /**\n     * A `Number` that defines the line width to use when rendering the body outline (if a sprite is not defined).\n     * A value of `0` means no outline will be rendered.\n     *\n     * @property render.lineWidth\n     * @type number\n     * @default 0\n     */\n\n    /**\n     * A `String` that defines the fill style to use when rendering the body (if a sprite is not defined).\n     * It is the same as when using a canvas, so it accepts CSS style property values.\n     *\n     * @property render.fillStyle\n     * @type string\n     * @default a random colour\n     */\n\n    /**\n     * A `String` that defines the stroke style to use when rendering the body outline (if a sprite is not defined).\n     * It is the same as when using a canvas, so it accepts CSS style property values.\n     *\n     * @property render.strokeStyle\n     * @type string\n     * @default a random colour\n     */\n\n    /**\n     * An array of unique axis vectors (edge normals) used for collision detection.\n     * These are automatically calculated from the given convex hull (`vertices` array) in `Body.create`.\n     * They are constantly updated by `Body.update` during the simulation.\n     *\n     * @property axes\n     * @type vector[]\n     */\n     \n    /**\n     * A `Number` that _measures_ the area of the body's convex hull, calculated at creation by `Body.create`.\n     *\n     * @property area\n     * @type string\n     * @default \n     */\n\n    /**\n     * A `Bounds` object that defines the AABB region for the body.\n     * It is automatically calculated from the given convex hull (`vertices` array) in `Body.create` and constantly updated by `Body.update` during simulation.\n     *\n     * @property bounds\n     * @type bounds\n     */\n\n})();\n\n},{\"../core/Common\":14,\"../core/Sleeping\":22,\"../geometry/Axes\":25,\"../geometry/Bounds\":26,\"../geometry/Vector\":28,\"../geometry/Vertices\":29,\"../render/Render\":31}],2:[function(_dereq_,module,exports){\n/**\n* The `Matter.Composite` module contains methods for creating and manipulating composite bodies.\n* A composite body is a collection of `Matter.Body`, `Matter.Constraint` and other `Matter.Composite`, therefore composites form a tree structure.\n* It is important to use the functions in this module to modify composites, rather than directly modifying their properties.\n* Note that the `Matter.World` object is also a type of `Matter.Composite` and as such all composite methods here can also operate on a `Matter.World`.\n*\n* See the included usage [examples](https://github.com/liabru/matter-js/tree/master/examples).\n*\n* @class Composite\n*/\n\nvar Composite = {};\n\nmodule.exports = Composite;\n\nvar Events = _dereq_('../core/Events');\nvar Common = _dereq_('../core/Common');\nvar Body = _dereq_('./Body');\n\n(function() {\n\n    /**\n     * Creates a new composite. The options parameter is an object that specifies any properties you wish to override the defaults.\n     * See the properites section below for detailed information on what you can pass via the `options` object.\n     * @method create\n     * @param {} [options]\n     * @return {composite} A new composite\n     */\n    Composite.create = function(options) {\n        return Common.extend({ \n            id: Common.nextId(),\n            type: 'composite',\n            parent: null,\n            isModified: false,\n            bodies: [], \n            constraints: [], \n            composites: [],\n            label: 'Composite',\n            plugin: {}\n        }, options);\n    };\n\n    /**\n     * Sets the composite's `isModified` flag. \n     * If `updateParents` is true, all parents will be set (default: false).\n     * If `updateChildren` is true, all children will be set (default: false).\n     * @method setModified\n     * @param {composite} composite\n     * @param {boolean} isModified\n     * @param {boolean} [updateParents=false]\n     * @param {boolean} [updateChildren=false]\n     */\n    Composite.setModified = function(composite, isModified, updateParents, updateChildren) {\n        composite.isModified = isModified;\n\n        if (updateParents && composite.parent) {\n            Composite.setModified(composite.parent, isModified, updateParents, updateChildren);\n        }\n\n        if (updateChildren) {\n            for(var i = 0; i < composite.composites.length; i++) {\n                var childComposite = composite.composites[i];\n                Composite.setModified(childComposite, isModified, updateParents, updateChildren);\n            }\n        }\n    };\n\n    /**\n     * Generic add function. Adds one or many body(s), constraint(s) or a composite(s) to the given composite.\n     * Triggers `beforeAdd` and `afterAdd` events on the `composite`.\n     * @method add\n     * @param {composite} composite\n     * @param {} object\n     * @return {composite} The original composite with the objects added\n     */\n    Composite.add = function(composite, object) {\n        var objects = [].concat(object);\n\n        Events.trigger(composite, 'beforeAdd', { object: object });\n\n        for (var i = 0; i < objects.length; i++) {\n            var obj = objects[i];\n\n            switch (obj.type) {\n\n            case 'body':\n                // skip adding compound parts\n                if (obj.parent !== obj) {\n                    Common.warn('Composite.add: skipped adding a compound body part (you must add its parent instead)');\n                    break;\n                }\n\n                Composite.addBody(composite, obj);\n                break;\n            case 'constraint':\n                Composite.addConstraint(composite, obj);\n                break;\n            case 'composite':\n                Composite.addComposite(composite, obj);\n                break;\n            case 'mouseConstraint':\n                Composite.addConstraint(composite, obj.constraint);\n                break;\n\n            }\n        }\n\n        Events.trigger(composite, 'afterAdd', { object: object });\n\n        return composite;\n    };\n\n    /**\n     * Generic remove function. Removes one or many body(s), constraint(s) or a composite(s) to the given composite.\n     * Optionally searching its children recursively.\n     * Triggers `beforeRemove` and `afterRemove` events on the `composite`.\n     * @method remove\n     * @param {composite} composite\n     * @param {} object\n     * @param {boolean} [deep=false]\n     * @return {composite} The original composite with the objects removed\n     */\n    Composite.remove = function(composite, object, deep) {\n        var objects = [].concat(object);\n\n        Events.trigger(composite, 'beforeRemove', { object: object });\n\n        for (var i = 0; i < objects.length; i++) {\n            var obj = objects[i];\n\n            switch (obj.type) {\n\n            case 'body':\n                Composite.removeBody(composite, obj, deep);\n                break;\n            case 'constraint':\n                Composite.removeConstraint(composite, obj, deep);\n                break;\n            case 'composite':\n                Composite.removeComposite(composite, obj, deep);\n                break;\n            case 'mouseConstraint':\n                Composite.removeConstraint(composite, obj.constraint);\n                break;\n\n            }\n        }\n\n        Events.trigger(composite, 'afterRemove', { object: object });\n\n        return composite;\n    };\n\n    /**\n     * Adds a composite to the given composite.\n     * @private\n     * @method addComposite\n     * @param {composite} compositeA\n     * @param {composite} compositeB\n     * @return {composite} The original compositeA with the objects from compositeB added\n     */\n    Composite.addComposite = function(compositeA, compositeB) {\n        compositeA.composites.push(compositeB);\n        compositeB.parent = compositeA;\n        Composite.setModified(compositeA, true, true, false);\n        return compositeA;\n    };\n\n    /**\n     * Removes a composite from the given composite, and optionally searching its children recursively.\n     * @private\n     * @method removeComposite\n     * @param {composite} compositeA\n     * @param {composite} compositeB\n     * @param {boolean} [deep=false]\n     * @return {composite} The original compositeA with the composite removed\n     */\n    Composite.removeComposite = function(compositeA, compositeB, deep) {\n        var position = Common.indexOf(compositeA.composites, compositeB);\n        if (position !== -1) {\n            Composite.removeCompositeAt(compositeA, position);\n            Composite.setModified(compositeA, true, true, false);\n        }\n\n        if (deep) {\n            for (var i = 0; i < compositeA.composites.length; i++){\n                Composite.removeComposite(compositeA.composites[i], compositeB, true);\n            }\n        }\n\n        return compositeA;\n    };\n\n    /**\n     * Removes a composite from the given composite.\n     * @private\n     * @method removeCompositeAt\n     * @param {composite} composite\n     * @param {number} position\n     * @return {composite} The original composite with the composite removed\n     */\n    Composite.removeCompositeAt = function(composite, position) {\n        composite.composites.splice(position, 1);\n        Composite.setModified(composite, true, true, false);\n        return composite;\n    };\n\n    /**\n     * Adds a body to the given composite.\n     * @private\n     * @method addBody\n     * @param {composite} composite\n     * @param {body} body\n     * @return {composite} The original composite with the body added\n     */\n    Composite.addBody = function(composite, body) {\n        composite.bodies.push(body);\n        Composite.setModified(composite, true, true, false);\n        return composite;\n    };\n\n    /**\n     * Removes a body from the given composite, and optionally searching its children recursively.\n     * @private\n     * @method removeBody\n     * @param {composite} composite\n     * @param {body} body\n     * @param {boolean} [deep=false]\n     * @return {composite} The original composite with the body removed\n     */\n    Composite.removeBody = function(composite, body, deep) {\n        var position = Common.indexOf(composite.bodies, body);\n        if (position !== -1) {\n            Composite.removeBodyAt(composite, position);\n            Composite.setModified(composite, true, true, false);\n        }\n\n        if (deep) {\n            for (var i = 0; i < composite.composites.length; i++){\n                Composite.removeBody(composite.composites[i], body, true);\n            }\n        }\n\n        return composite;\n    };\n\n    /**\n     * Removes a body from the given composite.\n     * @private\n     * @method removeBodyAt\n     * @param {composite} composite\n     * @param {number} position\n     * @return {composite} The original composite with the body removed\n     */\n    Composite.removeBodyAt = function(composite, position) {\n        composite.bodies.splice(position, 1);\n        Composite.setModified(composite, true, true, false);\n        return composite;\n    };\n\n    /**\n     * Adds a constraint to the given composite.\n     * @private\n     * @method addConstraint\n     * @param {composite} composite\n     * @param {constraint} constraint\n     * @return {composite} The original composite with the constraint added\n     */\n    Composite.addConstraint = function(composite, constraint) {\n        composite.constraints.push(constraint);\n        Composite.setModified(composite, true, true, false);\n        return composite;\n    };\n\n    /**\n     * Removes a constraint from the given composite, and optionally searching its children recursively.\n     * @private\n     * @method removeConstraint\n     * @param {composite} composite\n     * @param {constraint} constraint\n     * @param {boolean} [deep=false]\n     * @return {composite} The original composite with the constraint removed\n     */\n    Composite.removeConstraint = function(composite, constraint, deep) {\n        var position = Common.indexOf(composite.constraints, constraint);\n        if (position !== -1) {\n            Composite.removeConstraintAt(composite, position);\n        }\n\n        if (deep) {\n            for (var i = 0; i < composite.composites.length; i++){\n                Composite.removeConstraint(composite.composites[i], constraint, true);\n            }\n        }\n\n        return composite;\n    };\n\n    /**\n     * Removes a body from the given composite.\n     * @private\n     * @method removeConstraintAt\n     * @param {composite} composite\n     * @param {number} position\n     * @return {composite} The original composite with the constraint removed\n     */\n    Composite.removeConstraintAt = function(composite, position) {\n        composite.constraints.splice(position, 1);\n        Composite.setModified(composite, true, true, false);\n        return composite;\n    };\n\n    /**\n     * Removes all bodies, constraints and composites from the given composite.\n     * Optionally clearing its children recursively.\n     * @method clear\n     * @param {composite} composite\n     * @param {boolean} keepStatic\n     * @param {boolean} [deep=false]\n     */\n    Composite.clear = function(composite, keepStatic, deep) {\n        if (deep) {\n            for (var i = 0; i < composite.composites.length; i++){\n                Composite.clear(composite.composites[i], keepStatic, true);\n            }\n        }\n        \n        if (keepStatic) {\n            composite.bodies = composite.bodies.filter(function(body) { return body.isStatic; });\n        } else {\n            composite.bodies.length = 0;\n        }\n\n        composite.constraints.length = 0;\n        composite.composites.length = 0;\n        Composite.setModified(composite, true, true, false);\n\n        return composite;\n    };\n\n    /**\n     * Returns all bodies in the given composite, including all bodies in its children, recursively.\n     * @method allBodies\n     * @param {composite} composite\n     * @return {body[]} All the bodies\n     */\n    Composite.allBodies = function(composite) {\n        var bodies = [].concat(composite.bodies);\n\n        for (var i = 0; i < composite.composites.length; i++)\n            bodies = bodies.concat(Composite.allBodies(composite.composites[i]));\n\n        return bodies;\n    };\n\n    /**\n     * Returns all constraints in the given composite, including all constraints in its children, recursively.\n     * @method allConstraints\n     * @param {composite} composite\n     * @return {constraint[]} All the constraints\n     */\n    Composite.allConstraints = function(composite) {\n        var constraints = [].concat(composite.constraints);\n\n        for (var i = 0; i < composite.composites.length; i++)\n            constraints = constraints.concat(Composite.allConstraints(composite.composites[i]));\n\n        return constraints;\n    };\n\n    /**\n     * Returns all composites in the given composite, including all composites in its children, recursively.\n     * @method allComposites\n     * @param {composite} composite\n     * @return {composite[]} All the composites\n     */\n    Composite.allComposites = function(composite) {\n        var composites = [].concat(composite.composites);\n\n        for (var i = 0; i < composite.composites.length; i++)\n            composites = composites.concat(Composite.allComposites(composite.composites[i]));\n\n        return composites;\n    };\n\n    /**\n     * Searches the composite recursively for an object matching the type and id supplied, null if not found.\n     * @method get\n     * @param {composite} composite\n     * @param {number} id\n     * @param {string} type\n     * @return {object} The requested object, if found\n     */\n    Composite.get = function(composite, id, type) {\n        var objects,\n            object;\n\n        switch (type) {\n        case 'body':\n            objects = Composite.allBodies(composite);\n            break;\n        case 'constraint':\n            objects = Composite.allConstraints(composite);\n            break;\n        case 'composite':\n            objects = Composite.allComposites(composite).concat(composite);\n            break;\n        }\n\n        if (!objects)\n            return null;\n\n        object = objects.filter(function(object) { \n            return object.id.toString() === id.toString(); \n        });\n\n        return object.length === 0 ? null : object[0];\n    };\n\n    /**\n     * Moves the given object(s) from compositeA to compositeB (equal to a remove followed by an add).\n     * @method move\n     * @param {compositeA} compositeA\n     * @param {object[]} objects\n     * @param {compositeB} compositeB\n     * @return {composite} Returns compositeA\n     */\n    Composite.move = function(compositeA, objects, compositeB) {\n        Composite.remove(compositeA, objects);\n        Composite.add(compositeB, objects);\n        return compositeA;\n    };\n\n    /**\n     * Assigns new ids for all objects in the composite, recursively.\n     * @method rebase\n     * @param {composite} composite\n     * @return {composite} Returns composite\n     */\n    Composite.rebase = function(composite) {\n        var objects = Composite.allBodies(composite)\n                        .concat(Composite.allConstraints(composite))\n                        .concat(Composite.allComposites(composite));\n\n        for (var i = 0; i < objects.length; i++) {\n            objects[i].id = Common.nextId();\n        }\n\n        Composite.setModified(composite, true, true, false);\n\n        return composite;\n    };\n\n    /**\n     * Translates all children in the composite by a given vector relative to their current positions, \n     * without imparting any velocity.\n     * @method translate\n     * @param {composite} composite\n     * @param {vector} translation\n     * @param {bool} [recursive=true]\n     */\n    Composite.translate = function(composite, translation, recursive) {\n        var bodies = recursive ? Composite.allBodies(composite) : composite.bodies;\n\n        for (var i = 0; i < bodies.length; i++) {\n            Body.translate(bodies[i], translation);\n        }\n\n        Composite.setModified(composite, true, true, false);\n\n        return composite;\n    };\n\n    /**\n     * Rotates all children in the composite by a given angle about the given point, without imparting any angular velocity.\n     * @method rotate\n     * @param {composite} composite\n     * @param {number} rotation\n     * @param {vector} point\n     * @param {bool} [recursive=true]\n     */\n    Composite.rotate = function(composite, rotation, point, recursive) {\n        var cos = Math.cos(rotation),\n            sin = Math.sin(rotation),\n            bodies = recursive ? Composite.allBodies(composite) : composite.bodies;\n\n        for (var i = 0; i < bodies.length; i++) {\n            var body = bodies[i],\n                dx = body.position.x - point.x,\n                dy = body.position.y - point.y;\n                \n            Body.setPosition(body, {\n                x: point.x + (dx * cos - dy * sin),\n                y: point.y + (dx * sin + dy * cos)\n            });\n\n            Body.rotate(body, rotation);\n        }\n\n        Composite.setModified(composite, true, true, false);\n\n        return composite;\n    };\n\n    /**\n     * Scales all children in the composite, including updating physical properties (mass, area, axes, inertia), from a world-space point.\n     * @method scale\n     * @param {composite} composite\n     * @param {number} scaleX\n     * @param {number} scaleY\n     * @param {vector} point\n     * @param {bool} [recursive=true]\n     */\n    Composite.scale = function(composite, scaleX, scaleY, point, recursive) {\n        var bodies = recursive ? Composite.allBodies(composite) : composite.bodies;\n\n        for (var i = 0; i < bodies.length; i++) {\n            var body = bodies[i],\n                dx = body.position.x - point.x,\n                dy = body.position.y - point.y;\n                \n            Body.setPosition(body, {\n                x: point.x + dx * scaleX,\n                y: point.y + dy * scaleY\n            });\n\n            Body.scale(body, scaleX, scaleY);\n        }\n\n        Composite.setModified(composite, true, true, false);\n\n        return composite;\n    };\n\n    /**\n     * Returns the union of the bounds of all of the composite's bodies.\n     * @method bounds\n     * @param {composite} composite The composite.\n     * @returns {bounds} The composite bounds.\n     */\n    Composite.bounds = function(composite) {\n        var bodies = Matter.Composite.allBodies(composite),\n            vertices = [];\n\n        for (var i = 0; i < bodies.length; i += 1) {\n            var body = bodies[i];\n            vertices.push(body.bounds.min, body.bounds.max);\n        }\n\n        return Matter.Bounds.create(vertices);\n    };\n\n    /*\n    *\n    *  Events Documentation\n    *\n    */\n\n    /**\n    * Fired when a call to `Composite.add` is made, before objects have been added.\n    *\n    * @event beforeAdd\n    * @param {} event An event object\n    * @param {} event.object The object(s) to be added (may be a single body, constraint, composite or a mixed array of these)\n    * @param {} event.source The source object of the event\n    * @param {} event.name The name of the event\n    */\n\n    /**\n    * Fired when a call to `Composite.add` is made, after objects have been added.\n    *\n    * @event afterAdd\n    * @param {} event An event object\n    * @param {} event.object The object(s) that have been added (may be a single body, constraint, composite or a mixed array of these)\n    * @param {} event.source The source object of the event\n    * @param {} event.name The name of the event\n    */\n\n    /**\n    * Fired when a call to `Composite.remove` is made, before objects have been removed.\n    *\n    * @event beforeRemove\n    * @param {} event An event object\n    * @param {} event.object The object(s) to be removed (may be a single body, constraint, composite or a mixed array of these)\n    * @param {} event.source The source object of the event\n    * @param {} event.name The name of the event\n    */\n\n    /**\n    * Fired when a call to `Composite.remove` is made, after objects have been removed.\n    *\n    * @event afterRemove\n    * @param {} event An event object\n    * @param {} event.object The object(s) that have been removed (may be a single body, constraint, composite or a mixed array of these)\n    * @param {} event.source The source object of the event\n    * @param {} event.name The name of the event\n    */\n\n    /*\n    *\n    *  Properties Documentation\n    *\n    */\n\n    /**\n     * An integer `Number` uniquely identifying number generated in `Composite.create` by `Common.nextId`.\n     *\n     * @property id\n     * @type number\n     */\n\n    /**\n     * A `String` denoting the type of object.\n     *\n     * @property type\n     * @type string\n     * @default \"composite\"\n     * @readOnly\n     */\n\n    /**\n     * An arbitrary `String` name to help the user identify and manage composites.\n     *\n     * @property label\n     * @type string\n     * @default \"Composite\"\n     */\n\n    /**\n     * A flag that specifies whether the composite has been modified during the current step.\n     * Most `Matter.Composite` methods will automatically set this flag to `true` to inform the engine of changes to be handled.\n     * If you need to change it manually, you should use the `Composite.setModified` method.\n     *\n     * @property isModified\n     * @type boolean\n     * @default false\n     */\n\n    /**\n     * The `Composite` that is the parent of this composite. It is automatically managed by the `Matter.Composite` methods.\n     *\n     * @property parent\n     * @type composite\n     * @default null\n     */\n\n    /**\n     * An array of `Body` that are _direct_ children of this composite.\n     * To add or remove bodies you should use `Composite.add` and `Composite.remove` methods rather than directly modifying this property.\n     * If you wish to recursively find all descendants, you should use the `Composite.allBodies` method.\n     *\n     * @property bodies\n     * @type body[]\n     * @default []\n     */\n\n    /**\n     * An array of `Constraint` that are _direct_ children of this composite.\n     * To add or remove constraints you should use `Composite.add` and `Composite.remove` methods rather than directly modifying this property.\n     * If you wish to recursively find all descendants, you should use the `Composite.allConstraints` method.\n     *\n     * @property constraints\n     * @type constraint[]\n     * @default []\n     */\n\n    /**\n     * An array of `Composite` that are _direct_ children of this composite.\n     * To add or remove composites you should use `Composite.add` and `Composite.remove` methods rather than directly modifying this property.\n     * If you wish to recursively find all descendants, you should use the `Composite.allComposites` method.\n     *\n     * @property composites\n     * @type composite[]\n     * @default []\n     */\n\n    /**\n     * An object reserved for storing plugin-specific properties.\n     *\n     * @property plugin\n     * @type {}\n     */\n\n})();\n\n},{\"../core/Common\":14,\"../core/Events\":16,\"./Body\":1}],3:[function(_dereq_,module,exports){\n/**\n* The `Matter.World` module contains methods for creating and manipulating the world composite.\n* A `Matter.World` is a `Matter.Composite` body, which is a collection of `Matter.Body`, `Matter.Constraint` and other `Matter.Composite`.\n* A `Matter.World` has a few additional properties including `gravity` and `bounds`.\n* It is important to use the functions in the `Matter.Composite` module to modify the world composite, rather than directly modifying its properties.\n* There are also a few methods here that alias those in `Matter.Composite` for easier readability.\n*\n* See the included usage [examples](https://github.com/liabru/matter-js/tree/master/examples).\n*\n* @class World\n* @extends Composite\n*/\n\nvar World = {};\n\nmodule.exports = World;\n\nvar Composite = _dereq_('./Composite');\nvar Constraint = _dereq_('../constraint/Constraint');\nvar Common = _dereq_('../core/Common');\n\n(function() {\n\n    /**\n     * Creates a new world composite. The options parameter is an object that specifies any properties you wish to override the defaults.\n     * See the properties section below for detailed information on what you can pass via the `options` object.\n     * @method create\n     * @constructor\n     * @param {} options\n     * @return {world} A new world\n     */\n    World.create = function(options) {\n        var composite = Composite.create();\n\n        var defaults = {\n            label: 'World',\n            gravity: {\n                x: 0,\n                y: 1,\n                scale: 0.001\n            },\n            bounds: { \n                min: { x: -Infinity, y: -Infinity }, \n                max: { x: Infinity, y: Infinity } \n            }\n        };\n        \n        return Common.extend(composite, defaults, options);\n    };\n\n    /*\n    *\n    *  Properties Documentation\n    *\n    */\n\n    /**\n     * The gravity to apply on the world.\n     *\n     * @property gravity\n     * @type object\n     */\n\n    /**\n     * The gravity x component.\n     *\n     * @property gravity.x\n     * @type object\n     * @default 0\n     */\n\n    /**\n     * The gravity y component.\n     *\n     * @property gravity.y\n     * @type object\n     * @default 1\n     */\n\n    /**\n     * The gravity scale factor.\n     *\n     * @property gravity.scale\n     * @type object\n     * @default 0.001\n     */\n\n    /**\n     * A `Bounds` object that defines the world bounds for collision detection.\n     *\n     * @property bounds\n     * @type bounds\n     * @default { min: { x: -Infinity, y: -Infinity }, max: { x: Infinity, y: Infinity } }\n     */\n\n    // World is a Composite body\n    // see src/module/Outro.js for these aliases:\n    \n    /**\n     * An alias for Composite.add\n     * @method add\n     * @param {world} world\n     * @param {} object\n     * @return {composite} The original world with the objects added\n     */\n\n    /**\n     * An alias for Composite.remove\n     * @method remove\n     * @param {world} world\n     * @param {} object\n     * @param {boolean} [deep=false]\n     * @return {composite} The original world with the objects removed\n     */\n\n    /**\n     * An alias for Composite.clear\n     * @method clear\n     * @param {world} world\n     * @param {boolean} keepStatic\n     */\n\n    /**\n     * An alias for Composite.addComposite\n     * @method addComposite\n     * @param {world} world\n     * @param {composite} composite\n     * @return {world} The original world with the objects from composite added\n     */\n    \n     /**\n      * An alias for Composite.addBody\n      * @method addBody\n      * @param {world} world\n      * @param {body} body\n      * @return {world} The original world with the body added\n      */\n\n     /**\n      * An alias for Composite.addConstraint\n      * @method addConstraint\n      * @param {world} world\n      * @param {constraint} constraint\n      * @return {world} The original world with the constraint added\n      */\n\n})();\n\n},{\"../constraint/Constraint\":12,\"../core/Common\":14,\"./Composite\":2}],4:[function(_dereq_,module,exports){\n/**\n* The `Matter.Contact` module contains methods for creating and manipulating collision contacts.\n*\n* @class Contact\n*/\n\nvar Contact = {};\n\nmodule.exports = Contact;\n\n(function() {\n\n    /**\n     * Creates a new contact.\n     * @method create\n     * @param {vertex} vertex\n     * @return {contact} A new contact\n     */\n    Contact.create = function(vertex) {\n        return {\n            id: Contact.id(vertex),\n            vertex: vertex,\n            normalImpulse: 0,\n            tangentImpulse: 0\n        };\n    };\n    \n    /**\n     * Generates a contact id.\n     * @method id\n     * @param {vertex} vertex\n     * @return {string} Unique contactID\n     */\n    Contact.id = function(vertex) {\n        return vertex.body.id + '_' + vertex.index;\n    };\n\n})();\n\n},{}],5:[function(_dereq_,module,exports){\n/**\n* The `Matter.Detector` module contains methods for detecting collisions given a set of pairs.\n*\n* @class Detector\n*/\n\n// TODO: speculative contacts\n\nvar Detector = {};\n\nmodule.exports = Detector;\n\nvar SAT = _dereq_('./SAT');\nvar Pair = _dereq_('./Pair');\nvar Bounds = _dereq_('../geometry/Bounds');\n\n(function() {\n\n    /**\n     * Finds all collisions given a list of pairs.\n     * @method collisions\n     * @param {pair[]} broadphasePairs\n     * @param {engine} engine\n     * @return {array} collisions\n     */\n    Detector.collisions = function(broadphasePairs, engine) {\n        var collisions = [],\n            pairsTable = engine.pairs.table;\n\n        \n        for (var i = 0; i < broadphasePairs.length; i++) {\n            var bodyA = broadphasePairs[i][0], \n                bodyB = broadphasePairs[i][1];\n\n            if ((bodyA.isStatic || bodyA.isSleeping) && (bodyB.isStatic || bodyB.isSleeping))\n                continue;\n            \n            if (!Detector.canCollide(bodyA.collisionFilter, bodyB.collisionFilter))\n                continue;\n\n\n            // mid phase\n            if (Bounds.overlaps(bodyA.bounds, bodyB.bounds)) {\n                for (var j = bodyA.parts.length > 1 ? 1 : 0; j < bodyA.parts.length; j++) {\n                    var partA = bodyA.parts[j];\n\n                    for (var k = bodyB.parts.length > 1 ? 1 : 0; k < bodyB.parts.length; k++) {\n                        var partB = bodyB.parts[k];\n\n                        if ((partA === bodyA && partB === bodyB) || Bounds.overlaps(partA.bounds, partB.bounds)) {\n                            // find a previous collision we could reuse\n                            var pairId = Pair.id(partA, partB),\n                                pair = pairsTable[pairId],\n                                previousCollision;\n\n                            if (pair && pair.isActive) {\n                                previousCollision = pair.collision;\n                            } else {\n                                previousCollision = null;\n                            }\n\n                            // narrow phase\n                            var collision = SAT.collides(partA, partB, previousCollision);\n\n\n                            if (collision.collided) {\n                                collisions.push(collision);\n                            }\n                        }\n                    }\n                }\n            }\n        }\n\n        return collisions;\n    };\n\n    /**\n     * Returns `true` if both supplied collision filters will allow a collision to occur.\n     * See `body.collisionFilter` for more information.\n     * @method canCollide\n     * @param {} filterA\n     * @param {} filterB\n     * @return {bool} `true` if collision can occur\n     */\n    Detector.canCollide = function(filterA, filterB) {\n        if (filterA.group === filterB.group && filterA.group !== 0)\n            return filterA.group > 0;\n\n        return (filterA.mask & filterB.category) !== 0 && (filterB.mask & filterA.category) !== 0;\n    };\n\n})();\n\n},{\"../geometry/Bounds\":26,\"./Pair\":7,\"./SAT\":11}],6:[function(_dereq_,module,exports){\n/**\n* The `Matter.Grid` module contains methods for creating and manipulating collision broadphase grid structures.\n*\n* @class Grid\n*/\n\nvar Grid = {};\n\nmodule.exports = Grid;\n\nvar Pair = _dereq_('./Pair');\nvar Detector = _dereq_('./Detector');\nvar Common = _dereq_('../core/Common');\n\n(function() {\n\n    /**\n     * Creates a new grid.\n     * @method create\n     * @param {} options\n     * @return {grid} A new grid\n     */\n    Grid.create = function(options) {\n        var defaults = {\n            controller: Grid,\n            detector: Detector.collisions,\n            buckets: {},\n            pairs: {},\n            pairsList: [],\n            bucketWidth: 48,\n            bucketHeight: 48\n        };\n\n        return Common.extend(defaults, options);\n    };\n\n    /**\n     * The width of a single grid bucket.\n     *\n     * @property bucketWidth\n     * @type number\n     * @default 48\n     */\n\n    /**\n     * The height of a single grid bucket.\n     *\n     * @property bucketHeight\n     * @type number\n     * @default 48\n     */\n\n    /**\n     * Updates the grid.\n     * @method update\n     * @param {grid} grid\n     * @param {body[]} bodies\n     * @param {engine} engine\n     * @param {boolean} forceUpdate\n     */\n    Grid.update = function(grid, bodies, engine, forceUpdate) {\n        var i, col, row,\n            world = engine.world,\n            buckets = grid.buckets,\n            bucket,\n            bucketId,\n            gridChanged = false;\n\n\n        for (i = 0; i < bodies.length; i++) {\n            var body = bodies[i];\n\n            if (body.isSleeping && !forceUpdate)\n                continue;\n\n            // don't update out of world bodies\n            if (body.bounds.max.x < world.bounds.min.x || body.bounds.min.x > world.bounds.max.x\n                || body.bounds.max.y < world.bounds.min.y || body.bounds.min.y > world.bounds.max.y)\n                continue;\n\n            var newRegion = Grid._getRegion(grid, body);\n\n            // if the body has changed grid region\n            if (!body.region || newRegion.id !== body.region.id || forceUpdate) {\n\n\n                if (!body.region || forceUpdate)\n                    body.region = newRegion;\n\n                var union = Grid._regionUnion(newRegion, body.region);\n\n                // update grid buckets affected by region change\n                // iterate over the union of both regions\n                for (col = union.startCol; col <= union.endCol; col++) {\n                    for (row = union.startRow; row <= union.endRow; row++) {\n                        bucketId = Grid._getBucketId(col, row);\n                        bucket = buckets[bucketId];\n\n                        var isInsideNewRegion = (col >= newRegion.startCol && col <= newRegion.endCol\n                                                && row >= newRegion.startRow && row <= newRegion.endRow);\n\n                        var isInsideOldRegion = (col >= body.region.startCol && col <= body.region.endCol\n                                                && row >= body.region.startRow && row <= body.region.endRow);\n\n                        // remove from old region buckets\n                        if (!isInsideNewRegion && isInsideOldRegion) {\n                            if (isInsideOldRegion) {\n                                if (bucket)\n                                    Grid._bucketRemoveBody(grid, bucket, body);\n                            }\n                        }\n\n                        // add to new region buckets\n                        if (body.region === newRegion || (isInsideNewRegion && !isInsideOldRegion) || forceUpdate) {\n                            if (!bucket)\n                                bucket = Grid._createBucket(buckets, bucketId);\n                            Grid._bucketAddBody(grid, bucket, body);\n                        }\n                    }\n                }\n\n                // set the new region\n                body.region = newRegion;\n\n                // flag changes so we can update pairs\n                gridChanged = true;\n            }\n        }\n\n        // update pairs list only if pairs changed (i.e. a body changed region)\n        if (gridChanged)\n            grid.pairsList = Grid._createActivePairsList(grid);\n    };\n\n    /**\n     * Clears the grid.\n     * @method clear\n     * @param {grid} grid\n     */\n    Grid.clear = function(grid) {\n        grid.buckets = {};\n        grid.pairs = {};\n        grid.pairsList = [];\n    };\n\n    /**\n     * Finds the union of two regions.\n     * @method _regionUnion\n     * @private\n     * @param {} regionA\n     * @param {} regionB\n     * @return {} region\n     */\n    Grid._regionUnion = function(regionA, regionB) {\n        var startCol = Math.min(regionA.startCol, regionB.startCol),\n            endCol = Math.max(regionA.endCol, regionB.endCol),\n            startRow = Math.min(regionA.startRow, regionB.startRow),\n            endRow = Math.max(regionA.endRow, regionB.endRow);\n\n        return Grid._createRegion(startCol, endCol, startRow, endRow);\n    };\n\n    /**\n     * Gets the region a given body falls in for a given grid.\n     * @method _getRegion\n     * @private\n     * @param {} grid\n     * @param {} body\n     * @return {} region\n     */\n    Grid._getRegion = function(grid, body) {\n        var bounds = body.bounds,\n            startCol = Math.floor(bounds.min.x / grid.bucketWidth),\n            endCol = Math.floor(bounds.max.x / grid.bucketWidth),\n            startRow = Math.floor(bounds.min.y / grid.bucketHeight),\n            endRow = Math.floor(bounds.max.y / grid.bucketHeight);\n\n        return Grid._createRegion(startCol, endCol, startRow, endRow);\n    };\n\n    /**\n     * Creates a region.\n     * @method _createRegion\n     * @private\n     * @param {} startCol\n     * @param {} endCol\n     * @param {} startRow\n     * @param {} endRow\n     * @return {} region\n     */\n    Grid._createRegion = function(startCol, endCol, startRow, endRow) {\n        return { \n            id: startCol + ',' + endCol + ',' + startRow + ',' + endRow,\n            startCol: startCol, \n            endCol: endCol, \n            startRow: startRow, \n            endRow: endRow \n        };\n    };\n\n    /**\n     * Gets the bucket id at the given position.\n     * @method _getBucketId\n     * @private\n     * @param {} column\n     * @param {} row\n     * @return {string} bucket id\n     */\n    Grid._getBucketId = function(column, row) {\n        return 'C' + column + 'R' + row;\n    };\n\n    /**\n     * Creates a bucket.\n     * @method _createBucket\n     * @private\n     * @param {} buckets\n     * @param {} bucketId\n     * @return {} bucket\n     */\n    Grid._createBucket = function(buckets, bucketId) {\n        var bucket = buckets[bucketId] = [];\n        return bucket;\n    };\n\n    /**\n     * Adds a body to a bucket.\n     * @method _bucketAddBody\n     * @private\n     * @param {} grid\n     * @param {} bucket\n     * @param {} body\n     */\n    Grid._bucketAddBody = function(grid, bucket, body) {\n        // add new pairs\n        for (var i = 0; i < bucket.length; i++) {\n            var bodyB = bucket[i];\n\n            if (body.id === bodyB.id || (body.isStatic && bodyB.isStatic))\n                continue;\n\n            // keep track of the number of buckets the pair exists in\n            // important for Grid.update to work\n            var pairId = Pair.id(body, bodyB),\n                pair = grid.pairs[pairId];\n\n            if (pair) {\n                pair[2] += 1;\n            } else {\n                grid.pairs[pairId] = [body, bodyB, 1];\n            }\n        }\n\n        // add to bodies (after pairs, otherwise pairs with self)\n        bucket.push(body);\n    };\n\n    /**\n     * Removes a body from a bucket.\n     * @method _bucketRemoveBody\n     * @private\n     * @param {} grid\n     * @param {} bucket\n     * @param {} body\n     */\n    Grid._bucketRemoveBody = function(grid, bucket, body) {\n        // remove from bucket\n        bucket.splice(Common.indexOf(bucket, body), 1);\n\n        // update pair counts\n        for (var i = 0; i < bucket.length; i++) {\n            // keep track of the number of buckets the pair exists in\n            // important for _createActivePairsList to work\n            var bodyB = bucket[i],\n                pairId = Pair.id(body, bodyB),\n                pair = grid.pairs[pairId];\n\n            if (pair)\n                pair[2] -= 1;\n        }\n    };\n\n    /**\n     * Generates a list of the active pairs in the grid.\n     * @method _createActivePairsList\n     * @private\n     * @param {} grid\n     * @return [] pairs\n     */\n    Grid._createActivePairsList = function(grid) {\n        var pairKeys,\n            pair,\n            pairs = [];\n\n        // grid.pairs is used as a hashmap\n        pairKeys = Common.keys(grid.pairs);\n\n        // iterate over grid.pairs\n        for (var k = 0; k < pairKeys.length; k++) {\n            pair = grid.pairs[pairKeys[k]];\n\n            // if pair exists in at least one bucket\n            // it is a pair that needs further collision testing so push it\n            if (pair[2] > 0) {\n                pairs.push(pair);\n            } else {\n                delete grid.pairs[pairKeys[k]];\n            }\n        }\n\n        return pairs;\n    };\n    \n})();\n\n},{\"../core/Common\":14,\"./Detector\":5,\"./Pair\":7}],7:[function(_dereq_,module,exports){\n/**\n* The `Matter.Pair` module contains methods for creating and manipulating collision pairs.\n*\n* @class Pair\n*/\n\nvar Pair = {};\n\nmodule.exports = Pair;\n\nvar Contact = _dereq_('./Contact');\n\n(function() {\n    \n    /**\n     * Creates a pair.\n     * @method create\n     * @param {collision} collision\n     * @param {number} timestamp\n     * @return {pair} A new pair\n     */\n    Pair.create = function(collision, timestamp) {\n        var bodyA = collision.bodyA,\n            bodyB = collision.bodyB,\n            parentA = collision.parentA,\n            parentB = collision.parentB;\n\n        var pair = {\n            id: Pair.id(bodyA, bodyB),\n            bodyA: bodyA,\n            bodyB: bodyB,\n            contacts: {},\n            activeContacts: [],\n            separation: 0,\n            isActive: true,\n            isSensor: bodyA.isSensor || bodyB.isSensor,\n            timeCreated: timestamp,\n            timeUpdated: timestamp,\n            inverseMass: parentA.inverseMass + parentB.inverseMass,\n            friction: Math.min(parentA.friction, parentB.friction),\n            frictionStatic: Math.max(parentA.frictionStatic, parentB.frictionStatic),\n            restitution: Math.max(parentA.restitution, parentB.restitution),\n            slop: Math.max(parentA.slop, parentB.slop)\n        };\n\n        Pair.update(pair, collision, timestamp);\n\n        return pair;\n    };\n\n    /**\n     * Updates a pair given a collision.\n     * @method update\n     * @param {pair} pair\n     * @param {collision} collision\n     * @param {number} timestamp\n     */\n    Pair.update = function(pair, collision, timestamp) {\n        var contacts = pair.contacts,\n            supports = collision.supports,\n            activeContacts = pair.activeContacts,\n            parentA = collision.parentA,\n            parentB = collision.parentB;\n        \n        pair.collision = collision;\n        pair.inverseMass = parentA.inverseMass + parentB.inverseMass;\n        pair.friction = Math.min(parentA.friction, parentB.friction);\n        pair.frictionStatic = Math.max(parentA.frictionStatic, parentB.frictionStatic);\n        pair.restitution = Math.max(parentA.restitution, parentB.restitution);\n        pair.slop = Math.max(parentA.slop, parentB.slop);\n        activeContacts.length = 0;\n        \n        if (collision.collided) {\n            for (var i = 0; i < supports.length; i++) {\n                var support = supports[i],\n                    contactId = Contact.id(support),\n                    contact = contacts[contactId];\n\n                if (contact) {\n                    activeContacts.push(contact);\n                } else {\n                    activeContacts.push(contacts[contactId] = Contact.create(support));\n                }\n            }\n\n            pair.separation = collision.depth;\n            Pair.setActive(pair, true, timestamp);\n        } else {\n            if (pair.isActive === true)\n                Pair.setActive(pair, false, timestamp);\n        }\n    };\n    \n    /**\n     * Set a pair as active or inactive.\n     * @method setActive\n     * @param {pair} pair\n     * @param {bool} isActive\n     * @param {number} timestamp\n     */\n    Pair.setActive = function(pair, isActive, timestamp) {\n        if (isActive) {\n            pair.isActive = true;\n            pair.timeUpdated = timestamp;\n        } else {\n            pair.isActive = false;\n            pair.activeContacts.length = 0;\n        }\n    };\n\n    /**\n     * Get the id for the given pair.\n     * @method id\n     * @param {body} bodyA\n     * @param {body} bodyB\n     * @return {string} Unique pairId\n     */\n    Pair.id = function(bodyA, bodyB) {\n        if (bodyA.id < bodyB.id) {\n            return 'A' + bodyA.id + 'B' + bodyB.id;\n        } else {\n            return 'A' + bodyB.id + 'B' + bodyA.id;\n        }\n    };\n\n})();\n\n},{\"./Contact\":4}],8:[function(_dereq_,module,exports){\n/**\n* The `Matter.Pairs` module contains methods for creating and manipulating collision pair sets.\n*\n* @class Pairs\n*/\n\nvar Pairs = {};\n\nmodule.exports = Pairs;\n\nvar Pair = _dereq_('./Pair');\nvar Common = _dereq_('../core/Common');\n\n(function() {\n    \n    Pairs._pairMaxIdleLife = 1000;\n\n    /**\n     * Creates a new pairs structure.\n     * @method create\n     * @param {object} options\n     * @return {pairs} A new pairs structure\n     */\n    Pairs.create = function(options) {\n        return Common.extend({ \n            table: {},\n            list: [],\n            collisionStart: [],\n            collisionActive: [],\n            collisionEnd: []\n        }, options);\n    };\n\n    /**\n     * Updates pairs given a list of collisions.\n     * @method update\n     * @param {object} pairs\n     * @param {collision[]} collisions\n     * @param {number} timestamp\n     */\n    Pairs.update = function(pairs, collisions, timestamp) {\n        var pairsList = pairs.list,\n            pairsTable = pairs.table,\n            collisionStart = pairs.collisionStart,\n            collisionEnd = pairs.collisionEnd,\n            collisionActive = pairs.collisionActive,\n            activePairIds = [],\n            collision,\n            pairId,\n            pair,\n            i;\n\n        // clear collision state arrays, but maintain old reference\n        collisionStart.length = 0;\n        collisionEnd.length = 0;\n        collisionActive.length = 0;\n\n        for (i = 0; i < collisions.length; i++) {\n            collision = collisions[i];\n\n            if (collision.collided) {\n                pairId = Pair.id(collision.bodyA, collision.bodyB);\n                activePairIds.push(pairId);\n\n                pair = pairsTable[pairId];\n                \n                if (pair) {\n                    // pair already exists (but may or may not be active)\n                    if (pair.isActive) {\n                        // pair exists and is active\n                        collisionActive.push(pair);\n                    } else {\n                        // pair exists but was inactive, so a collision has just started again\n                        collisionStart.push(pair);\n                    }\n\n                    // update the pair\n                    Pair.update(pair, collision, timestamp);\n                } else {\n                    // pair did not exist, create a new pair\n                    pair = Pair.create(collision, timestamp);\n                    pairsTable[pairId] = pair;\n\n                    // push the new pair\n                    collisionStart.push(pair);\n                    pairsList.push(pair);\n                }\n            }\n        }\n\n        // deactivate previously active pairs that are now inactive\n        for (i = 0; i < pairsList.length; i++) {\n            pair = pairsList[i];\n            if (pair.isActive && Common.indexOf(activePairIds, pair.id) === -1) {\n                Pair.setActive(pair, false, timestamp);\n                collisionEnd.push(pair);\n            }\n        }\n    };\n    \n    /**\n     * Finds and removes pairs that have been inactive for a set amount of time.\n     * @method removeOld\n     * @param {object} pairs\n     * @param {number} timestamp\n     */\n    Pairs.removeOld = function(pairs, timestamp) {\n        var pairsList = pairs.list,\n            pairsTable = pairs.table,\n            indexesToRemove = [],\n            pair,\n            collision,\n            pairIndex,\n            i;\n\n        for (i = 0; i < pairsList.length; i++) {\n            pair = pairsList[i];\n            collision = pair.collision;\n            \n            // never remove sleeping pairs\n            if (collision.bodyA.isSleeping || collision.bodyB.isSleeping) {\n                pair.timeUpdated = timestamp;\n                continue;\n            }\n\n            // if pair is inactive for too long, mark it to be removed\n            if (timestamp - pair.timeUpdated > Pairs._pairMaxIdleLife) {\n                indexesToRemove.push(i);\n            }\n        }\n\n        // remove marked pairs\n        for (i = 0; i < indexesToRemove.length; i++) {\n            pairIndex = indexesToRemove[i] - i;\n            pair = pairsList[pairIndex];\n            delete pairsTable[pair.id];\n            pairsList.splice(pairIndex, 1);\n        }\n    };\n\n    /**\n     * Clears the given pairs structure.\n     * @method clear\n     * @param {pairs} pairs\n     * @return {pairs} pairs\n     */\n    Pairs.clear = function(pairs) {\n        pairs.table = {};\n        pairs.list.length = 0;\n        pairs.collisionStart.length = 0;\n        pairs.collisionActive.length = 0;\n        pairs.collisionEnd.length = 0;\n        return pairs;\n    };\n\n})();\n\n},{\"../core/Common\":14,\"./Pair\":7}],9:[function(_dereq_,module,exports){\n/**\n* The `Matter.Query` module contains methods for performing collision queries.\n*\n* See the included usage [examples](https://github.com/liabru/matter-js/tree/master/examples).\n*\n* @class Query\n*/\n\nvar Query = {};\n\nmodule.exports = Query;\n\nvar Vector = _dereq_('../geometry/Vector');\nvar SAT = _dereq_('./SAT');\nvar Bounds = _dereq_('../geometry/Bounds');\nvar Bodies = _dereq_('../factory/Bodies');\nvar Vertices = _dereq_('../geometry/Vertices');\n\n(function() {\n\n    /**\n     * Returns a list of collisions between `body` and `bodies`.\n     * @method collides\n     * @param {body} body\n     * @param {body[]} bodies\n     * @return {object[]} Collisions\n     */\n    Query.collides = function(body, bodies) {\n        var collisions = [];\n\n        for (var i = 0; i < bodies.length; i++) {\n            var bodyA = bodies[i];\n            \n            if (Bounds.overlaps(bodyA.bounds, body.bounds)) {\n                for (var j = bodyA.parts.length === 1 ? 0 : 1; j < bodyA.parts.length; j++) {\n                    var part = bodyA.parts[j];\n\n                    if (Bounds.overlaps(part.bounds, body.bounds)) {\n                        var collision = SAT.collides(part, body);\n\n                        if (collision.collided) {\n                            collisions.push(collision);\n                            break;\n                        }\n                    }\n                }\n            }\n        }\n\n        return collisions;\n    };\n\n    /**\n     * Casts a ray segment against a set of bodies and returns all collisions, ray width is optional. Intersection points are not provided.\n     * @method ray\n     * @param {body[]} bodies\n     * @param {vector} startPoint\n     * @param {vector} endPoint\n     * @param {number} [rayWidth]\n     * @return {object[]} Collisions\n     */\n    Query.ray = function(bodies, startPoint, endPoint, rayWidth) {\n        rayWidth = rayWidth || 1e-100;\n\n        var rayAngle = Vector.angle(startPoint, endPoint),\n            rayLength = Vector.magnitude(Vector.sub(startPoint, endPoint)),\n            rayX = (endPoint.x + startPoint.x) * 0.5,\n            rayY = (endPoint.y + startPoint.y) * 0.5,\n            ray = Bodies.rectangle(rayX, rayY, rayLength, rayWidth, { angle: rayAngle }),\n            collisions = Query.collides(ray, bodies);\n\n        for (var i = 0; i < collisions.length; i += 1) {\n            var collision = collisions[i];\n            collision.body = collision.bodyB = collision.bodyA;            \n        }\n\n        return collisions;\n    };\n\n    /**\n     * Returns all bodies whose bounds are inside (or outside if set) the given set of bounds, from the given set of bodies.\n     * @method region\n     * @param {body[]} bodies\n     * @param {bounds} bounds\n     * @param {bool} [outside=false]\n     * @return {body[]} The bodies matching the query\n     */\n    Query.region = function(bodies, bounds, outside) {\n        var result = [];\n\n        for (var i = 0; i < bodies.length; i++) {\n            var body = bodies[i],\n                overlaps = Bounds.overlaps(body.bounds, bounds);\n            if ((overlaps && !outside) || (!overlaps && outside))\n                result.push(body);\n        }\n\n        return result;\n    };\n\n    /**\n     * Returns all bodies whose vertices contain the given point, from the given set of bodies.\n     * @method point\n     * @param {body[]} bodies\n     * @param {vector} point\n     * @return {body[]} The bodies matching the query\n     */\n    Query.point = function(bodies, point) {\n        var result = [];\n\n        for (var i = 0; i < bodies.length; i++) {\n            var body = bodies[i];\n            \n            if (Bounds.contains(body.bounds, point)) {\n                for (var j = body.parts.length === 1 ? 0 : 1; j < body.parts.length; j++) {\n                    var part = body.parts[j];\n\n                    if (Bounds.contains(part.bounds, point)\n                        && Vertices.contains(part.vertices, point)) {\n                        result.push(body);\n                        break;\n                    }\n                }\n            }\n        }\n\n        return result;\n    };\n\n})();\n\n},{\"../factory/Bodies\":23,\"../geometry/Bounds\":26,\"../geometry/Vector\":28,\"../geometry/Vertices\":29,\"./SAT\":11}],10:[function(_dereq_,module,exports){\n/**\n* The `Matter.Resolver` module contains methods for resolving collision pairs.\n*\n* @class Resolver\n*/\n\nvar Resolver = {};\n\nmodule.exports = Resolver;\n\nvar Vertices = _dereq_('../geometry/Vertices');\nvar Vector = _dereq_('../geometry/Vector');\nvar Common = _dereq_('../core/Common');\nvar Bounds = _dereq_('../geometry/Bounds');\n\n(function() {\n\n    Resolver._restingThresh = 4;\n    Resolver._restingThreshTangent = 6;\n    Resolver._positionDampen = 0.9;\n    Resolver._positionWarming = 0.8;\n    Resolver._frictionNormalMultiplier = 5;\n\n    /**\n     * Prepare pairs for position solving.\n     * @method preSolvePosition\n     * @param {pair[]} pairs\n     */\n    Resolver.preSolvePosition = function(pairs) {\n        var i,\n            pair,\n            activeCount;\n\n        // find total contacts on each body\n        for (i = 0; i < pairs.length; i++) {\n            pair = pairs[i];\n            \n            if (!pair.isActive)\n                continue;\n            \n            activeCount = pair.activeContacts.length;\n            pair.collision.parentA.totalContacts += activeCount;\n            pair.collision.parentB.totalContacts += activeCount;\n        }\n    };\n\n    /**\n     * Find a solution for pair positions.\n     * @method solvePosition\n     * @param {pair[]} pairs\n     * @param {number} timeScale\n     */\n    Resolver.solvePosition = function(pairs, timeScale) {\n        var i,\n            pair,\n            collision,\n            bodyA,\n            bodyB,\n            normal,\n            bodyBtoA,\n            contactShare,\n            positionImpulse,\n            contactCount = {},\n            tempA = Vector._temp[0],\n            tempB = Vector._temp[1],\n            tempC = Vector._temp[2],\n            tempD = Vector._temp[3];\n\n        // find impulses required to resolve penetration\n        for (i = 0; i < pairs.length; i++) {\n            pair = pairs[i];\n            \n            if (!pair.isActive || pair.isSensor)\n                continue;\n\n            collision = pair.collision;\n            bodyA = collision.parentA;\n            bodyB = collision.parentB;\n            normal = collision.normal;\n\n            // get current separation between body edges involved in collision\n            bodyBtoA = Vector.sub(Vector.add(bodyB.positionImpulse, bodyB.position, tempA), \n                                    Vector.add(bodyA.positionImpulse, \n                                        Vector.sub(bodyB.position, collision.penetration, tempB), tempC), tempD);\n\n            pair.separation = Vector.dot(normal, bodyBtoA);\n        }\n        \n        for (i = 0; i < pairs.length; i++) {\n            pair = pairs[i];\n\n            if (!pair.isActive || pair.isSensor)\n                continue;\n            \n            collision = pair.collision;\n            bodyA = collision.parentA;\n            bodyB = collision.parentB;\n            normal = collision.normal;\n            positionImpulse = (pair.separation - pair.slop) * timeScale;\n\n            if (bodyA.isStatic || bodyB.isStatic)\n                positionImpulse *= 2;\n            \n            if (!(bodyA.isStatic || bodyA.isSleeping)) {\n                contactShare = Resolver._positionDampen / bodyA.totalContacts;\n                bodyA.positionImpulse.x += normal.x * positionImpulse * contactShare;\n                bodyA.positionImpulse.y += normal.y * positionImpulse * contactShare;\n            }\n\n            if (!(bodyB.isStatic || bodyB.isSleeping)) {\n                contactShare = Resolver._positionDampen / bodyB.totalContacts;\n                bodyB.positionImpulse.x -= normal.x * positionImpulse * contactShare;\n                bodyB.positionImpulse.y -= normal.y * positionImpulse * contactShare;\n            }\n        }\n    };\n\n    /**\n     * Apply position resolution.\n     * @method postSolvePosition\n     * @param {body[]} bodies\n     */\n    Resolver.postSolvePosition = function(bodies) {\n        for (var i = 0; i < bodies.length; i++) {\n            var body = bodies[i];\n\n            // reset contact count\n            body.totalContacts = 0;\n\n            if (body.positionImpulse.x !== 0 || body.positionImpulse.y !== 0) {\n                // update body geometry\n                for (var j = 0; j < body.parts.length; j++) {\n                    var part = body.parts[j];\n                    Vertices.translate(part.vertices, body.positionImpulse);\n                    Bounds.update(part.bounds, part.vertices, body.velocity);\n                    part.position.x += body.positionImpulse.x;\n                    part.position.y += body.positionImpulse.y;\n                }\n\n                // move the body without changing velocity\n                body.positionPrev.x += body.positionImpulse.x;\n                body.positionPrev.y += body.positionImpulse.y;\n\n                if (Vector.dot(body.positionImpulse, body.velocity) < 0) {\n                    // reset cached impulse if the body has velocity along it\n                    body.positionImpulse.x = 0;\n                    body.positionImpulse.y = 0;\n                } else {\n                    // warm the next iteration\n                    body.positionImpulse.x *= Resolver._positionWarming;\n                    body.positionImpulse.y *= Resolver._positionWarming;\n                }\n            }\n        }\n    };\n\n    /**\n     * Prepare pairs for velocity solving.\n     * @method preSolveVelocity\n     * @param {pair[]} pairs\n     */\n    Resolver.preSolveVelocity = function(pairs) {\n        var i,\n            j,\n            pair,\n            contacts,\n            collision,\n            bodyA,\n            bodyB,\n            normal,\n            tangent,\n            contact,\n            contactVertex,\n            normalImpulse,\n            tangentImpulse,\n            offset,\n            impulse = Vector._temp[0],\n            tempA = Vector._temp[1];\n        \n        for (i = 0; i < pairs.length; i++) {\n            pair = pairs[i];\n            \n            if (!pair.isActive || pair.isSensor)\n                continue;\n            \n            contacts = pair.activeContacts;\n            collision = pair.collision;\n            bodyA = collision.parentA;\n            bodyB = collision.parentB;\n            normal = collision.normal;\n            tangent = collision.tangent;\n\n            // resolve each contact\n            for (j = 0; j < contacts.length; j++) {\n                contact = contacts[j];\n                contactVertex = contact.vertex;\n                normalImpulse = contact.normalImpulse;\n                tangentImpulse = contact.tangentImpulse;\n\n                if (normalImpulse !== 0 || tangentImpulse !== 0) {\n                    // total impulse from contact\n                    impulse.x = (normal.x * normalImpulse) + (tangent.x * tangentImpulse);\n                    impulse.y = (normal.y * normalImpulse) + (tangent.y * tangentImpulse);\n                    \n                    // apply impulse from contact\n                    if (!(bodyA.isStatic || bodyA.isSleeping)) {\n                        offset = Vector.sub(contactVertex, bodyA.position, tempA);\n                        bodyA.positionPrev.x += impulse.x * bodyA.inverseMass;\n                        bodyA.positionPrev.y += impulse.y * bodyA.inverseMass;\n                        bodyA.anglePrev += Vector.cross(offset, impulse) * bodyA.inverseInertia;\n                    }\n\n                    if (!(bodyB.isStatic || bodyB.isSleeping)) {\n                        offset = Vector.sub(contactVertex, bodyB.position, tempA);\n                        bodyB.positionPrev.x -= impulse.x * bodyB.inverseMass;\n                        bodyB.positionPrev.y -= impulse.y * bodyB.inverseMass;\n                        bodyB.anglePrev -= Vector.cross(offset, impulse) * bodyB.inverseInertia;\n                    }\n                }\n            }\n        }\n    };\n\n    /**\n     * Find a solution for pair velocities.\n     * @method solveVelocity\n     * @param {pair[]} pairs\n     * @param {number} timeScale\n     */\n    Resolver.solveVelocity = function(pairs, timeScale) {\n        var timeScaleSquared = timeScale * timeScale,\n            impulse = Vector._temp[0],\n            tempA = Vector._temp[1],\n            tempB = Vector._temp[2],\n            tempC = Vector._temp[3],\n            tempD = Vector._temp[4],\n            tempE = Vector._temp[5];\n        \n        for (var i = 0; i < pairs.length; i++) {\n            var pair = pairs[i];\n            \n            if (!pair.isActive || pair.isSensor)\n                continue;\n            \n            var collision = pair.collision,\n                bodyA = collision.parentA,\n                bodyB = collision.parentB,\n                normal = collision.normal,\n                tangent = collision.tangent,\n                contacts = pair.activeContacts,\n                contactShare = 1 / contacts.length;\n\n            // update body velocities\n            bodyA.velocity.x = bodyA.position.x - bodyA.positionPrev.x;\n            bodyA.velocity.y = bodyA.position.y - bodyA.positionPrev.y;\n            bodyB.velocity.x = bodyB.position.x - bodyB.positionPrev.x;\n            bodyB.velocity.y = bodyB.position.y - bodyB.positionPrev.y;\n            bodyA.angularVelocity = bodyA.angle - bodyA.anglePrev;\n            bodyB.angularVelocity = bodyB.angle - bodyB.anglePrev;\n\n            // resolve each contact\n            for (var j = 0; j < contacts.length; j++) {\n                var contact = contacts[j],\n                    contactVertex = contact.vertex,\n                    offsetA = Vector.sub(contactVertex, bodyA.position, tempA),\n                    offsetB = Vector.sub(contactVertex, bodyB.position, tempB),\n                    velocityPointA = Vector.add(bodyA.velocity, Vector.mult(Vector.perp(offsetA), bodyA.angularVelocity), tempC),\n                    velocityPointB = Vector.add(bodyB.velocity, Vector.mult(Vector.perp(offsetB), bodyB.angularVelocity), tempD), \n                    relativeVelocity = Vector.sub(velocityPointA, velocityPointB, tempE),\n                    normalVelocity = Vector.dot(normal, relativeVelocity);\n\n                var tangentVelocity = Vector.dot(tangent, relativeVelocity),\n                    tangentSpeed = Math.abs(tangentVelocity),\n                    tangentVelocityDirection = Common.sign(tangentVelocity);\n\n                // raw impulses\n                var normalImpulse = (1 + pair.restitution) * normalVelocity,\n                    normalForce = Common.clamp(pair.separation + normalVelocity, 0, 1) * Resolver._frictionNormalMultiplier;\n\n                // coulomb friction\n                var tangentImpulse = tangentVelocity,\n                    maxFriction = Infinity;\n\n                if (tangentSpeed > pair.friction * pair.frictionStatic * normalForce * timeScaleSquared) {\n                    maxFriction = tangentSpeed;\n                    tangentImpulse = Common.clamp(\n                        pair.friction * tangentVelocityDirection * timeScaleSquared,\n                        -maxFriction, maxFriction\n                    );\n                }\n\n                // modify impulses accounting for mass, inertia and offset\n                var oAcN = Vector.cross(offsetA, normal),\n                    oBcN = Vector.cross(offsetB, normal),\n                    share = contactShare / (bodyA.inverseMass + bodyB.inverseMass + bodyA.inverseInertia * oAcN * oAcN  + bodyB.inverseInertia * oBcN * oBcN);\n\n                normalImpulse *= share;\n                tangentImpulse *= share;\n\n                // handle high velocity and resting collisions separately\n                if (normalVelocity < 0 && normalVelocity * normalVelocity > Resolver._restingThresh * timeScaleSquared) {\n                    // high normal velocity so clear cached contact normal impulse\n                    contact.normalImpulse = 0;\n                } else {\n                    // solve resting collision constraints using Erin Catto's method (GDC08)\n                    // impulse constraint tends to 0\n                    var contactNormalImpulse = contact.normalImpulse;\n                    contact.normalImpulse = Math.min(contact.normalImpulse + normalImpulse, 0);\n                    normalImpulse = contact.normalImpulse - contactNormalImpulse;\n                }\n\n                // handle high velocity and resting collisions separately\n                if (tangentVelocity * tangentVelocity > Resolver._restingThreshTangent * timeScaleSquared) {\n                    // high tangent velocity so clear cached contact tangent impulse\n                    contact.tangentImpulse = 0;\n                } else {\n                    // solve resting collision constraints using Erin Catto's method (GDC08)\n                    // tangent impulse tends to -tangentSpeed or +tangentSpeed\n                    var contactTangentImpulse = contact.tangentImpulse;\n                    contact.tangentImpulse = Common.clamp(contact.tangentImpulse + tangentImpulse, -maxFriction, maxFriction);\n                    tangentImpulse = contact.tangentImpulse - contactTangentImpulse;\n                }\n\n                // total impulse from contact\n                impulse.x = (normal.x * normalImpulse) + (tangent.x * tangentImpulse);\n                impulse.y = (normal.y * normalImpulse) + (tangent.y * tangentImpulse);\n                \n                // apply impulse from contact\n                if (!(bodyA.isStatic || bodyA.isSleeping)) {\n                    bodyA.positionPrev.x += impulse.x * bodyA.inverseMass;\n                    bodyA.positionPrev.y += impulse.y * bodyA.inverseMass;\n                    bodyA.anglePrev += Vector.cross(offsetA, impulse) * bodyA.inverseInertia;\n                }\n\n                if (!(bodyB.isStatic || bodyB.isSleeping)) {\n                    bodyB.positionPrev.x -= impulse.x * bodyB.inverseMass;\n                    bodyB.positionPrev.y -= impulse.y * bodyB.inverseMass;\n                    bodyB.anglePrev -= Vector.cross(offsetB, impulse) * bodyB.inverseInertia;\n                }\n            }\n        }\n    };\n\n})();\n\n},{\"../core/Common\":14,\"../geometry/Bounds\":26,\"../geometry/Vector\":28,\"../geometry/Vertices\":29}],11:[function(_dereq_,module,exports){\n/**\n* The `Matter.SAT` module contains methods for detecting collisions using the Separating Axis Theorem.\n*\n* @class SAT\n*/\n\n// TODO: true circles and curves\n\nvar SAT = {};\n\nmodule.exports = SAT;\n\nvar Vertices = _dereq_('../geometry/Vertices');\nvar Vector = _dereq_('../geometry/Vector');\n\n(function() {\n\n    /**\n     * Detect collision between two bodies using the Separating Axis Theorem.\n     * @method collides\n     * @param {body} bodyA\n     * @param {body} bodyB\n     * @param {collision} previousCollision\n     * @return {collision} collision\n     */\n    SAT.collides = function(bodyA, bodyB, previousCollision) {\n        var overlapAB,\n            overlapBA, \n            minOverlap,\n            collision,\n            canReusePrevCol = false;\n\n        if (previousCollision) {\n            // estimate total motion\n            var parentA = bodyA.parent,\n                parentB = bodyB.parent,\n                motion = parentA.speed * parentA.speed + parentA.angularSpeed * parentA.angularSpeed\n                       + parentB.speed * parentB.speed + parentB.angularSpeed * parentB.angularSpeed;\n\n            // we may be able to (partially) reuse collision result \n            // but only safe if collision was resting\n            canReusePrevCol = previousCollision && previousCollision.collided && motion < 0.2;\n\n            // reuse collision object\n            collision = previousCollision;\n        } else {\n            collision = { collided: false, bodyA: bodyA, bodyB: bodyB };\n        }\n\n        if (previousCollision && canReusePrevCol) {\n            // if we can reuse the collision result\n            // we only need to test the previously found axis\n            var axisBodyA = collision.axisBody,\n                axisBodyB = axisBodyA === bodyA ? bodyB : bodyA,\n                axes = [axisBodyA.axes[previousCollision.axisNumber]];\n\n            minOverlap = SAT._overlapAxes(axisBodyA.vertices, axisBodyB.vertices, axes);\n            collision.reused = true;\n\n            if (minOverlap.overlap <= 0) {\n                collision.collided = false;\n                return collision;\n            }\n        } else {\n            // if we can't reuse a result, perform a full SAT test\n\n            overlapAB = SAT._overlapAxes(bodyA.vertices, bodyB.vertices, bodyA.axes);\n\n            if (overlapAB.overlap <= 0) {\n                collision.collided = false;\n                return collision;\n            }\n\n            overlapBA = SAT._overlapAxes(bodyB.vertices, bodyA.vertices, bodyB.axes);\n\n            if (overlapBA.overlap <= 0) {\n                collision.collided = false;\n                return collision;\n            }\n\n            if (overlapAB.overlap < overlapBA.overlap) {\n                minOverlap = overlapAB;\n                collision.axisBody = bodyA;\n            } else {\n                minOverlap = overlapBA;\n                collision.axisBody = bodyB;\n            }\n\n            // important for reuse later\n            collision.axisNumber = minOverlap.axisNumber;\n        }\n\n        collision.bodyA = bodyA.id < bodyB.id ? bodyA : bodyB;\n        collision.bodyB = bodyA.id < bodyB.id ? bodyB : bodyA;\n        collision.collided = true;\n        collision.depth = minOverlap.overlap;\n        collision.parentA = collision.bodyA.parent;\n        collision.parentB = collision.bodyB.parent;\n        \n        bodyA = collision.bodyA;\n        bodyB = collision.bodyB;\n\n        // ensure normal is facing away from bodyA\n        if (Vector.dot(minOverlap.axis, Vector.sub(bodyB.position, bodyA.position)) < 0) {\n            collision.normal = {\n                x: minOverlap.axis.x,\n                y: minOverlap.axis.y\n            };\n        } else {\n            collision.normal = {\n                x: -minOverlap.axis.x,\n                y: -minOverlap.axis.y\n            };\n        }\n\n        collision.tangent = Vector.perp(collision.normal);\n\n        collision.penetration = collision.penetration || {};\n        collision.penetration.x = collision.normal.x * collision.depth;\n        collision.penetration.y = collision.normal.y * collision.depth; \n\n        // find support points, there is always either exactly one or two\n        var verticesB = SAT._findSupports(bodyA, bodyB, collision.normal),\n            supports = [];\n\n        // find the supports from bodyB that are inside bodyA\n        if (Vertices.contains(bodyA.vertices, verticesB[0]))\n            supports.push(verticesB[0]);\n\n        if (Vertices.contains(bodyA.vertices, verticesB[1]))\n            supports.push(verticesB[1]);\n\n        // find the supports from bodyA that are inside bodyB\n        if (supports.length < 2) {\n            var verticesA = SAT._findSupports(bodyB, bodyA, Vector.neg(collision.normal));\n                \n            if (Vertices.contains(bodyB.vertices, verticesA[0]))\n                supports.push(verticesA[0]);\n\n            if (supports.length < 2 && Vertices.contains(bodyB.vertices, verticesA[1]))\n                supports.push(verticesA[1]);\n        }\n\n        // account for the edge case of overlapping but no vertex containment\n        if (supports.length < 1)\n            supports = [verticesB[0]];\n        \n        collision.supports = supports;\n\n        return collision;\n    };\n\n    /**\n     * Find the overlap between two sets of vertices.\n     * @method _overlapAxes\n     * @private\n     * @param {} verticesA\n     * @param {} verticesB\n     * @param {} axes\n     * @return result\n     */\n    SAT._overlapAxes = function(verticesA, verticesB, axes) {\n        var projectionA = Vector._temp[0], \n            projectionB = Vector._temp[1],\n            result = { overlap: Number.MAX_VALUE },\n            overlap,\n            axis;\n\n        for (var i = 0; i < axes.length; i++) {\n            axis = axes[i];\n\n            SAT._projectToAxis(projectionA, verticesA, axis);\n            SAT._projectToAxis(projectionB, verticesB, axis);\n\n            overlap = Math.min(projectionA.max - projectionB.min, projectionB.max - projectionA.min);\n\n            if (overlap <= 0) {\n                result.overlap = overlap;\n                return result;\n            }\n\n            if (overlap < result.overlap) {\n                result.overlap = overlap;\n                result.axis = axis;\n                result.axisNumber = i;\n            }\n        }\n\n        return result;\n    };\n\n    /**\n     * Projects vertices on an axis and returns an interval.\n     * @method _projectToAxis\n     * @private\n     * @param {} projection\n     * @param {} vertices\n     * @param {} axis\n     */\n    SAT._projectToAxis = function(projection, vertices, axis) {\n        var min = Vector.dot(vertices[0], axis),\n            max = min;\n\n        for (var i = 1; i < vertices.length; i += 1) {\n            var dot = Vector.dot(vertices[i], axis);\n\n            if (dot > max) { \n                max = dot; \n            } else if (dot < min) { \n                min = dot; \n            }\n        }\n\n        projection.min = min;\n        projection.max = max;\n    };\n    \n    /**\n     * Finds supporting vertices given two bodies along a given direction using hill-climbing.\n     * @method _findSupports\n     * @private\n     * @param {} bodyA\n     * @param {} bodyB\n     * @param {} normal\n     * @return [vector]\n     */\n    SAT._findSupports = function(bodyA, bodyB, normal) {\n        var nearestDistance = Number.MAX_VALUE,\n            vertexToBody = Vector._temp[0],\n            vertices = bodyB.vertices,\n            bodyAPosition = bodyA.position,\n            distance,\n            vertex,\n            vertexA,\n            vertexB;\n\n        // find closest vertex on bodyB\n        for (var i = 0; i < vertices.length; i++) {\n            vertex = vertices[i];\n            vertexToBody.x = vertex.x - bodyAPosition.x;\n            vertexToBody.y = vertex.y - bodyAPosition.y;\n            distance = -Vector.dot(normal, vertexToBody);\n\n            if (distance < nearestDistance) {\n                nearestDistance = distance;\n                vertexA = vertex;\n            }\n        }\n\n        // find next closest vertex using the two connected to it\n        var prevIndex = vertexA.index - 1 >= 0 ? vertexA.index - 1 : vertices.length - 1;\n        vertex = vertices[prevIndex];\n        vertexToBody.x = vertex.x - bodyAPosition.x;\n        vertexToBody.y = vertex.y - bodyAPosition.y;\n        nearestDistance = -Vector.dot(normal, vertexToBody);\n        vertexB = vertex;\n\n        var nextIndex = (vertexA.index + 1) % vertices.length;\n        vertex = vertices[nextIndex];\n        vertexToBody.x = vertex.x - bodyAPosition.x;\n        vertexToBody.y = vertex.y - bodyAPosition.y;\n        distance = -Vector.dot(normal, vertexToBody);\n        if (distance < nearestDistance) {\n            vertexB = vertex;\n        }\n\n        return [vertexA, vertexB];\n    };\n\n})();\n\n},{\"../geometry/Vector\":28,\"../geometry/Vertices\":29}],12:[function(_dereq_,module,exports){\n/**\n* The `Matter.Constraint` module contains methods for creating and manipulating constraints.\n* Constraints are used for specifying that a fixed distance must be maintained between two bodies (or a body and a fixed world-space position).\n* The stiffness of constraints can be modified to create springs or elastic.\n*\n* See the included usage [examples](https://github.com/liabru/matter-js/tree/master/examples).\n*\n* @class Constraint\n*/\n\nvar Constraint = {};\n\nmodule.exports = Constraint;\n\nvar Vertices = _dereq_('../geometry/Vertices');\nvar Vector = _dereq_('../geometry/Vector');\nvar Sleeping = _dereq_('../core/Sleeping');\nvar Bounds = _dereq_('../geometry/Bounds');\nvar Axes = _dereq_('../geometry/Axes');\nvar Common = _dereq_('../core/Common');\n\n(function() {\n\n    Constraint._warming = 0.4;\n    Constraint._torqueDampen = 1;\n    Constraint._minLength = 0.000001;\n\n    /**\n     * Creates a new constraint.\n     * All properties have default values, and many are pre-calculated automatically based on other properties.\n     * To simulate a revolute constraint (or pin joint) set `length: 0` and a high `stiffness` value (e.g. `0.7` or above).\n     * If the constraint is unstable, try lowering the `stiffness` value and / or increasing `engine.constraintIterations`.\n     * For compound bodies, constraints must be applied to the parent body (not one of its parts).\n     * See the properties section below for detailed information on what you can pass via the `options` object.\n     * @method create\n     * @param {} options\n     * @return {constraint} constraint\n     */\n    Constraint.create = function(options) {\n        var constraint = options;\n\n        // if bodies defined but no points, use body centre\n        if (constraint.bodyA && !constraint.pointA)\n            constraint.pointA = { x: 0, y: 0 };\n        if (constraint.bodyB && !constraint.pointB)\n            constraint.pointB = { x: 0, y: 0 };\n\n        // calculate static length using initial world space points\n        var initialPointA = constraint.bodyA ? Vector.add(constraint.bodyA.position, constraint.pointA) : constraint.pointA,\n            initialPointB = constraint.bodyB ? Vector.add(constraint.bodyB.position, constraint.pointB) : constraint.pointB,\n            length = Vector.magnitude(Vector.sub(initialPointA, initialPointB));\n    \n        constraint.length = typeof constraint.length !== 'undefined' ? constraint.length : length;\n\n        // option defaults\n        constraint.id = constraint.id || Common.nextId();\n        constraint.label = constraint.label || 'Constraint';\n        constraint.type = 'constraint';\n        constraint.stiffness = constraint.stiffness || (constraint.length > 0 ? 1 : 0.7);\n        constraint.damping = constraint.damping || 0;\n        constraint.angularStiffness = constraint.angularStiffness || 0;\n        constraint.angleA = constraint.bodyA ? constraint.bodyA.angle : constraint.angleA;\n        constraint.angleB = constraint.bodyB ? constraint.bodyB.angle : constraint.angleB;\n        constraint.plugin = {};\n\n        // render\n        var render = {\n            visible: true,\n            lineWidth: 2,\n            strokeStyle: '#ffffff',\n            type: 'line',\n            anchors: true\n        };\n\n        if (constraint.length === 0 && constraint.stiffness > 0.1) {\n            render.type = 'pin';\n            render.anchors = false;\n        } else if (constraint.stiffness < 0.9) {\n            render.type = 'spring';\n        }\n\n        constraint.render = Common.extend(render, constraint.render);\n\n        return constraint;\n    };\n\n    /**\n     * Prepares for solving by constraint warming.\n     * @private\n     * @method preSolveAll\n     * @param {body[]} bodies\n     */\n    Constraint.preSolveAll = function(bodies) {\n        for (var i = 0; i < bodies.length; i += 1) {\n            var body = bodies[i],\n                impulse = body.constraintImpulse;\n\n            if (body.isStatic || (impulse.x === 0 && impulse.y === 0 && impulse.angle === 0)) {\n                continue;\n            }\n\n            body.position.x += impulse.x;\n            body.position.y += impulse.y;\n            body.angle += impulse.angle;\n        }\n    };\n\n    /**\n     * Solves all constraints in a list of collisions.\n     * @private\n     * @method solveAll\n     * @param {constraint[]} constraints\n     * @param {number} timeScale\n     */\n    Constraint.solveAll = function(constraints, timeScale) {\n        // Solve fixed constraints first.\n        for (var i = 0; i < constraints.length; i += 1) {\n            var constraint = constraints[i],\n                fixedA = !constraint.bodyA || (constraint.bodyA && constraint.bodyA.isStatic),\n                fixedB = !constraint.bodyB || (constraint.bodyB && constraint.bodyB.isStatic);\n\n            if (fixedA || fixedB) {\n                Constraint.solve(constraints[i], timeScale);\n            }\n        }\n\n        // Solve free constraints last.\n        for (i = 0; i < constraints.length; i += 1) {\n            constraint = constraints[i];\n            fixedA = !constraint.bodyA || (constraint.bodyA && constraint.bodyA.isStatic);\n            fixedB = !constraint.bodyB || (constraint.bodyB && constraint.bodyB.isStatic);\n\n            if (!fixedA && !fixedB) {\n                Constraint.solve(constraints[i], timeScale);\n            }\n        }\n    };\n\n    /**\n     * Solves a distance constraint with Gauss-Siedel method.\n     * @private\n     * @method solve\n     * @param {constraint} constraint\n     * @param {number} timeScale\n     */\n    Constraint.solve = function(constraint, timeScale) {\n        var bodyA = constraint.bodyA,\n            bodyB = constraint.bodyB,\n            pointA = constraint.pointA,\n            pointB = constraint.pointB;\n\n        if (!bodyA && !bodyB)\n            return;\n\n        // update reference angle\n        if (bodyA && !bodyA.isStatic) {\n            Vector.rotate(pointA, bodyA.angle - constraint.angleA, pointA);\n            constraint.angleA = bodyA.angle;\n        }\n        \n        // update reference angle\n        if (bodyB && !bodyB.isStatic) {\n            Vector.rotate(pointB, bodyB.angle - constraint.angleB, pointB);\n            constraint.angleB = bodyB.angle;\n        }\n\n        var pointAWorld = pointA,\n            pointBWorld = pointB;\n\n        if (bodyA) pointAWorld = Vector.add(bodyA.position, pointA);\n        if (bodyB) pointBWorld = Vector.add(bodyB.position, pointB);\n\n        if (!pointAWorld || !pointBWorld)\n            return;\n\n        var delta = Vector.sub(pointAWorld, pointBWorld),\n            currentLength = Vector.magnitude(delta);\n\n        // prevent singularity\n        if (currentLength < Constraint._minLength) {\n            currentLength = Constraint._minLength;\n        }\n\n        // solve distance constraint with Gauss-Siedel method\n        var difference = (currentLength - constraint.length) / currentLength,\n            stiffness = constraint.stiffness < 1 ? constraint.stiffness * timeScale : constraint.stiffness,\n            force = Vector.mult(delta, difference * stiffness),\n            massTotal = (bodyA ? bodyA.inverseMass : 0) + (bodyB ? bodyB.inverseMass : 0),\n            inertiaTotal = (bodyA ? bodyA.inverseInertia : 0) + (bodyB ? bodyB.inverseInertia : 0),\n            resistanceTotal = massTotal + inertiaTotal,\n            torque,\n            share,\n            normal,\n            normalVelocity,\n            relativeVelocity;\n\n        if (constraint.damping) {\n            var zero = Vector.create();\n            normal = Vector.div(delta, currentLength);\n\n            relativeVelocity = Vector.sub(\n                bodyB && Vector.sub(bodyB.position, bodyB.positionPrev) || zero,\n                bodyA && Vector.sub(bodyA.position, bodyA.positionPrev) || zero\n            );\n\n            normalVelocity = Vector.dot(normal, relativeVelocity);\n        }\n\n        if (bodyA && !bodyA.isStatic) {\n            share = bodyA.inverseMass / massTotal;\n\n            // keep track of applied impulses for post solving\n            bodyA.constraintImpulse.x -= force.x * share;\n            bodyA.constraintImpulse.y -= force.y * share;\n\n            // apply forces\n            bodyA.position.x -= force.x * share;\n            bodyA.position.y -= force.y * share;\n\n            // apply damping\n            if (constraint.damping) {\n                bodyA.positionPrev.x -= constraint.damping * normal.x * normalVelocity * share;\n                bodyA.positionPrev.y -= constraint.damping * normal.y * normalVelocity * share;\n            }\n\n            // apply torque\n            torque = (Vector.cross(pointA, force) / resistanceTotal) * Constraint._torqueDampen * bodyA.inverseInertia * (1 - constraint.angularStiffness);\n            bodyA.constraintImpulse.angle -= torque;\n            bodyA.angle -= torque;\n        }\n\n        if (bodyB && !bodyB.isStatic) {\n            share = bodyB.inverseMass / massTotal;\n\n            // keep track of applied impulses for post solving\n            bodyB.constraintImpulse.x += force.x * share;\n            bodyB.constraintImpulse.y += force.y * share;\n            \n            // apply forces\n            bodyB.position.x += force.x * share;\n            bodyB.position.y += force.y * share;\n\n            // apply damping\n            if (constraint.damping) {\n                bodyB.positionPrev.x += constraint.damping * normal.x * normalVelocity * share;\n                bodyB.positionPrev.y += constraint.damping * normal.y * normalVelocity * share;\n            }\n\n            // apply torque\n            torque = (Vector.cross(pointB, force) / resistanceTotal) * Constraint._torqueDampen * bodyB.inverseInertia * (1 - constraint.angularStiffness);\n            bodyB.constraintImpulse.angle += torque;\n            bodyB.angle += torque;\n        }\n\n    };\n\n    /**\n     * Performs body updates required after solving constraints.\n     * @private\n     * @method postSolveAll\n     * @param {body[]} bodies\n     */\n    Constraint.postSolveAll = function(bodies) {\n        for (var i = 0; i < bodies.length; i++) {\n            var body = bodies[i],\n                impulse = body.constraintImpulse;\n\n            if (body.isStatic || (impulse.x === 0 && impulse.y === 0 && impulse.angle === 0)) {\n                continue;\n            }\n\n            Sleeping.set(body, false);\n\n            // update geometry and reset\n            for (var j = 0; j < body.parts.length; j++) {\n                var part = body.parts[j];\n                \n                Vertices.translate(part.vertices, impulse);\n\n                if (j > 0) {\n                    part.position.x += impulse.x;\n                    part.position.y += impulse.y;\n                }\n\n                if (impulse.angle !== 0) {\n                    Vertices.rotate(part.vertices, impulse.angle, body.position);\n                    Axes.rotate(part.axes, impulse.angle);\n                    if (j > 0) {\n                        Vector.rotateAbout(part.position, impulse.angle, body.position, part.position);\n                    }\n                }\n\n                Bounds.update(part.bounds, part.vertices, body.velocity);\n            }\n\n            // dampen the cached impulse for warming next step\n            impulse.angle *= Constraint._warming;\n            impulse.x *= Constraint._warming;\n            impulse.y *= Constraint._warming;\n        }\n    };\n\n    /*\n    *\n    *  Properties Documentation\n    *\n    */\n\n    /**\n     * An integer `Number` uniquely identifying number generated in `Composite.create` by `Common.nextId`.\n     *\n     * @property id\n     * @type number\n     */\n\n    /**\n     * A `String` denoting the type of object.\n     *\n     * @property type\n     * @type string\n     * @default \"constraint\"\n     * @readOnly\n     */\n\n    /**\n     * An arbitrary `String` name to help the user identify and manage bodies.\n     *\n     * @property label\n     * @type string\n     * @default \"Constraint\"\n     */\n\n    /**\n     * An `Object` that defines the rendering properties to be consumed by the module `Matter.Render`.\n     *\n     * @property render\n     * @type object\n     */\n\n    /**\n     * A flag that indicates if the constraint should be rendered.\n     *\n     * @property render.visible\n     * @type boolean\n     * @default true\n     */\n\n    /**\n     * A `Number` that defines the line width to use when rendering the constraint outline.\n     * A value of `0` means no outline will be rendered.\n     *\n     * @property render.lineWidth\n     * @type number\n     * @default 2\n     */\n\n    /**\n     * A `String` that defines the stroke style to use when rendering the constraint outline.\n     * It is the same as when using a canvas, so it accepts CSS style property values.\n     *\n     * @property render.strokeStyle\n     * @type string\n     * @default a random colour\n     */\n\n    /**\n     * A `String` that defines the constraint rendering type. \n     * The possible values are 'line', 'pin', 'spring'.\n     * An appropriate render type will be automatically chosen unless one is given in options.\n     *\n     * @property render.type\n     * @type string\n     * @default 'line'\n     */\n\n    /**\n     * A `Boolean` that defines if the constraint's anchor points should be rendered.\n     *\n     * @property render.anchors\n     * @type boolean\n     * @default true\n     */\n\n    /**\n     * The first possible `Body` that this constraint is attached to.\n     *\n     * @property bodyA\n     * @type body\n     * @default null\n     */\n\n    /**\n     * The second possible `Body` that this constraint is attached to.\n     *\n     * @property bodyB\n     * @type body\n     * @default null\n     */\n\n    /**\n     * A `Vector` that specifies the offset of the constraint from center of the `constraint.bodyA` if defined, otherwise a world-space position.\n     *\n     * @property pointA\n     * @type vector\n     * @default { x: 0, y: 0 }\n     */\n\n    /**\n     * A `Vector` that specifies the offset of the constraint from center of the `constraint.bodyA` if defined, otherwise a world-space position.\n     *\n     * @property pointB\n     * @type vector\n     * @default { x: 0, y: 0 }\n     */\n\n    /**\n     * A `Number` that specifies the stiffness of the constraint, i.e. the rate at which it returns to its resting `constraint.length`.\n     * A value of `1` means the constraint should be very stiff.\n     * A value of `0.2` means the constraint acts like a soft spring.\n     *\n     * @property stiffness\n     * @type number\n     * @default 1\n     */\n\n    /**\n     * A `Number` that specifies the damping of the constraint, \n     * i.e. the amount of resistance applied to each body based on their velocities to limit the amount of oscillation.\n     * Damping will only be apparent when the constraint also has a very low `stiffness`.\n     * A value of `0.1` means the constraint will apply heavy damping, resulting in little to no oscillation.\n     * A value of `0` means the constraint will apply no damping.\n     *\n     * @property damping\n     * @type number\n     * @default 0\n     */\n\n    /**\n     * A `Number` that specifies the target resting length of the constraint. \n     * It is calculated automatically in `Constraint.create` from initial positions of the `constraint.bodyA` and `constraint.bodyB`.\n     *\n     * @property length\n     * @type number\n     */\n\n    /**\n     * An object reserved for storing plugin-specific properties.\n     *\n     * @property plugin\n     * @type {}\n     */\n\n})();\n\n},{\"../core/Common\":14,\"../core/Sleeping\":22,\"../geometry/Axes\":25,\"../geometry/Bounds\":26,\"../geometry/Vector\":28,\"../geometry/Vertices\":29}],13:[function(_dereq_,module,exports){\n/**\n* The `Matter.MouseConstraint` module contains methods for creating mouse constraints.\n* Mouse constraints are used for allowing user interaction, providing the ability to move bodies via the mouse or touch.\n*\n* See the included usage [examples](https://github.com/liabru/matter-js/tree/master/examples).\n*\n* @class MouseConstraint\n*/\n\nvar MouseConstraint = {};\n\nmodule.exports = MouseConstraint;\n\nvar Vertices = _dereq_('../geometry/Vertices');\nvar Sleeping = _dereq_('../core/Sleeping');\nvar Mouse = _dereq_('../core/Mouse');\nvar Events = _dereq_('../core/Events');\nvar Detector = _dereq_('../collision/Detector');\nvar Constraint = _dereq_('./Constraint');\nvar Composite = _dereq_('../body/Composite');\nvar Common = _dereq_('../core/Common');\nvar Bounds = _dereq_('../geometry/Bounds');\n\n(function() {\n\n    /**\n     * Creates a new mouse constraint.\n     * All properties have default values, and many are pre-calculated automatically based on other properties.\n     * See the properties section below for detailed information on what you can pass via the `options` object.\n     * @method create\n     * @param {engine} engine\n     * @param {} options\n     * @return {MouseConstraint} A new MouseConstraint\n     */\n    MouseConstraint.create = function(engine, options) {\n        var mouse = (engine ? engine.mouse : null) || (options ? options.mouse : null);\n\n        if (!mouse) {\n            if (engine && engine.render && engine.render.canvas) {\n                mouse = Mouse.create(engine.render.canvas);\n            } else if (options && options.element) {\n                mouse = Mouse.create(options.element);\n            } else {\n                mouse = Mouse.create();\n                Common.warn('MouseConstraint.create: options.mouse was undefined, options.element was undefined, may not function as expected');\n            }\n        }\n\n        var constraint = Constraint.create({ \n            label: 'Mouse Constraint',\n            pointA: mouse.position,\n            pointB: { x: 0, y: 0 },\n            length: 0.01, \n            stiffness: 0.1,\n            angularStiffness: 1,\n            render: {\n                strokeStyle: '#90EE90',\n                lineWidth: 3\n            }\n        });\n\n        var defaults = {\n            type: 'mouseConstraint',\n            mouse: mouse,\n            element: null,\n            body: null,\n            constraint: constraint,\n            collisionFilter: {\n                category: 0x0001,\n                mask: 0xFFFFFFFF,\n                group: 0\n            }\n        };\n\n        var mouseConstraint = Common.extend(defaults, options);\n\n        Events.on(engine, 'beforeUpdate', function() {\n            var allBodies = Composite.allBodies(engine.world);\n            MouseConstraint.update(mouseConstraint, allBodies);\n            MouseConstraint._triggerEvents(mouseConstraint);\n        });\n\n        return mouseConstraint;\n    };\n\n    /**\n     * Updates the given mouse constraint.\n     * @private\n     * @method update\n     * @param {MouseConstraint} mouseConstraint\n     * @param {body[]} bodies\n     */\n    MouseConstraint.update = function(mouseConstraint, bodies) {\n        var mouse = mouseConstraint.mouse,\n            constraint = mouseConstraint.constraint,\n            body = mouseConstraint.body;\n\n        if (mouse.button === 0) {\n            if (!constraint.bodyB) {\n                for (var i = 0; i < bodies.length; i++) {\n                    body = bodies[i];\n                    if (Bounds.contains(body.bounds, mouse.position) \n                            && Detector.canCollide(body.collisionFilter, mouseConstraint.collisionFilter)) {\n                        for (var j = body.parts.length > 1 ? 1 : 0; j < body.parts.length; j++) {\n                            var part = body.parts[j];\n                            if (Vertices.contains(part.vertices, mouse.position)) {\n                                constraint.pointA = mouse.position;\n                                constraint.bodyB = mouseConstraint.body = body;\n                                constraint.pointB = { x: mouse.position.x - body.position.x, y: mouse.position.y - body.position.y };\n                                constraint.angleB = body.angle;\n\n                                Sleeping.set(body, false);\n                                Events.trigger(mouseConstraint, 'startdrag', { mouse: mouse, body: body });\n\n                                break;\n                            }\n                        }\n                    }\n                }\n            } else {\n                Sleeping.set(constraint.bodyB, false);\n                constraint.pointA = mouse.position;\n            }\n        } else {\n            constraint.bodyB = mouseConstraint.body = null;\n            constraint.pointB = null;\n\n            if (body)\n                Events.trigger(mouseConstraint, 'enddrag', { mouse: mouse, body: body });\n        }\n    };\n\n    /**\n     * Triggers mouse constraint events.\n     * @method _triggerEvents\n     * @private\n     * @param {mouse} mouseConstraint\n     */\n    MouseConstraint._triggerEvents = function(mouseConstraint) {\n        var mouse = mouseConstraint.mouse,\n            mouseEvents = mouse.sourceEvents;\n\n        if (mouseEvents.mousemove)\n            Events.trigger(mouseConstraint, 'mousemove', { mouse: mouse });\n\n        if (mouseEvents.mousedown)\n            Events.trigger(mouseConstraint, 'mousedown', { mouse: mouse });\n\n        if (mouseEvents.mouseup)\n            Events.trigger(mouseConstraint, 'mouseup', { mouse: mouse });\n\n        // reset the mouse state ready for the next step\n        Mouse.clearSourceEvents(mouse);\n    };\n\n    /*\n    *\n    *  Events Documentation\n    *\n    */\n\n    /**\n    * Fired when the mouse has moved (or a touch moves) during the last step\n    *\n    * @event mousemove\n    * @param {} event An event object\n    * @param {mouse} event.mouse The engine's mouse instance\n    * @param {} event.source The source object of the event\n    * @param {} event.name The name of the event\n    */\n\n    /**\n    * Fired when the mouse is down (or a touch has started) during the last step\n    *\n    * @event mousedown\n    * @param {} event An event object\n    * @param {mouse} event.mouse The engine's mouse instance\n    * @param {} event.source The source object of the event\n    * @param {} event.name The name of the event\n    */\n\n    /**\n    * Fired when the mouse is up (or a touch has ended) during the last step\n    *\n    * @event mouseup\n    * @param {} event An event object\n    * @param {mouse} event.mouse The engine's mouse instance\n    * @param {} event.source The source object of the event\n    * @param {} event.name The name of the event\n    */\n\n    /**\n    * Fired when the user starts dragging a body\n    *\n    * @event startdrag\n    * @param {} event An event object\n    * @param {mouse} event.mouse The engine's mouse instance\n    * @param {body} event.body The body being dragged\n    * @param {} event.source The source object of the event\n    * @param {} event.name The name of the event\n    */\n\n    /**\n    * Fired when the user ends dragging a body\n    *\n    * @event enddrag\n    * @param {} event An event object\n    * @param {mouse} event.mouse The engine's mouse instance\n    * @param {body} event.body The body that has stopped being dragged\n    * @param {} event.source The source object of the event\n    * @param {} event.name The name of the event\n    */\n\n    /*\n    *\n    *  Properties Documentation\n    *\n    */\n\n    /**\n     * A `String` denoting the type of object.\n     *\n     * @property type\n     * @type string\n     * @default \"constraint\"\n     * @readOnly\n     */\n\n    /**\n     * The `Mouse` instance in use. If not supplied in `MouseConstraint.create`, one will be created.\n     *\n     * @property mouse\n     * @type mouse\n     * @default mouse\n     */\n\n    /**\n     * The `Body` that is currently being moved by the user, or `null` if no body.\n     *\n     * @property body\n     * @type body\n     * @default null\n     */\n\n    /**\n     * The `Constraint` object that is used to move the body during interaction.\n     *\n     * @property constraint\n     * @type constraint\n     */\n\n    /**\n     * An `Object` that specifies the collision filter properties.\n     * The collision filter allows the user to define which types of body this mouse constraint can interact with.\n     * See `body.collisionFilter` for more information.\n     *\n     * @property collisionFilter\n     * @type object\n     */\n\n})();\n\n},{\"../body/Composite\":2,\"../collision/Detector\":5,\"../core/Common\":14,\"../core/Events\":16,\"../core/Mouse\":19,\"../core/Sleeping\":22,\"../geometry/Bounds\":26,\"../geometry/Vertices\":29,\"./Constraint\":12}],14:[function(_dereq_,module,exports){\n/**\n* The `Matter.Common` module contains utility functions that are common to all modules.\n*\n* @class Common\n*/\n\nvar Common = {};\n\nmodule.exports = Common;\n\n(function() {\n\n    Common._nextId = 0;\n    Common._seed = 0;\n    Common._nowStartTime = +(new Date());\n\n    /**\n     * Extends the object in the first argument using the object in the second argument.\n     * @method extend\n     * @param {} obj\n     * @param {boolean} deep\n     * @return {} obj extended\n     */\n    Common.extend = function(obj, deep) {\n        var argsStart,\n            args,\n            deepClone;\n\n        if (typeof deep === 'boolean') {\n            argsStart = 2;\n            deepClone = deep;\n        } else {\n            argsStart = 1;\n            deepClone = true;\n        }\n\n        for (var i = argsStart; i < arguments.length; i++) {\n            var source = arguments[i];\n\n            if (source) {\n                for (var prop in source) {\n                    if (deepClone && source[prop] && source[prop].constructor === Object) {\n                        if (!obj[prop] || obj[prop].constructor === Object) {\n                            obj[prop] = obj[prop] || {};\n                            Common.extend(obj[prop], deepClone, source[prop]);\n                        } else {\n                            obj[prop] = source[prop];\n                        }\n                    } else {\n                        obj[prop] = source[prop];\n                    }\n                }\n            }\n        }\n        \n        return obj;\n    };\n\n    /**\n     * Creates a new clone of the object, if deep is true references will also be cloned.\n     * @method clone\n     * @param {} obj\n     * @param {bool} deep\n     * @return {} obj cloned\n     */\n    Common.clone = function(obj, deep) {\n        return Common.extend({}, deep, obj);\n    };\n\n    /**\n     * Returns the list of keys for the given object.\n     * @method keys\n     * @param {} obj\n     * @return {string[]} keys\n     */\n    Common.keys = function(obj) {\n        if (Object.keys)\n            return Object.keys(obj);\n\n        // avoid hasOwnProperty for performance\n        var keys = [];\n        for (var key in obj)\n            keys.push(key);\n        return keys;\n    };\n\n    /**\n     * Returns the list of values for the given object.\n     * @method values\n     * @param {} obj\n     * @return {array} Array of the objects property values\n     */\n    Common.values = function(obj) {\n        var values = [];\n        \n        if (Object.keys) {\n            var keys = Object.keys(obj);\n            for (var i = 0; i < keys.length; i++) {\n                values.push(obj[keys[i]]);\n            }\n            return values;\n        }\n        \n        // avoid hasOwnProperty for performance\n        for (var key in obj)\n            values.push(obj[key]);\n        return values;\n    };\n\n    /**\n     * Gets a value from `base` relative to the `path` string.\n     * @method get\n     * @param {} obj The base object\n     * @param {string} path The path relative to `base`, e.g. 'Foo.Bar.baz'\n     * @param {number} [begin] Path slice begin\n     * @param {number} [end] Path slice end\n     * @return {} The object at the given path\n     */\n    Common.get = function(obj, path, begin, end) {\n        path = path.split('.').slice(begin, end);\n\n        for (var i = 0; i < path.length; i += 1) {\n            obj = obj[path[i]];\n        }\n\n        return obj;\n    };\n\n    /**\n     * Sets a value on `base` relative to the given `path` string.\n     * @method set\n     * @param {} obj The base object\n     * @param {string} path The path relative to `base`, e.g. 'Foo.Bar.baz'\n     * @param {} val The value to set\n     * @param {number} [begin] Path slice begin\n     * @param {number} [end] Path slice end\n     * @return {} Pass through `val` for chaining\n     */\n    Common.set = function(obj, path, val, begin, end) {\n        var parts = path.split('.').slice(begin, end);\n        Common.get(obj, path, 0, -1)[parts[parts.length - 1]] = val;\n        return val;\n    };\n\n    /**\n     * Shuffles the given array in-place.\n     * The function uses a seeded random generator.\n     * @method shuffle\n     * @param {array} array\n     * @return {array} array shuffled randomly\n     */\n    Common.shuffle = function(array) {\n        for (var i = array.length - 1; i > 0; i--) {\n            var j = Math.floor(Common.random() * (i + 1));\n            var temp = array[i];\n            array[i] = array[j];\n            array[j] = temp;\n        }\n        return array;\n    };\n\n    /**\n     * Randomly chooses a value from a list with equal probability.\n     * The function uses a seeded random generator.\n     * @method choose\n     * @param {array} choices\n     * @return {object} A random choice object from the array\n     */\n    Common.choose = function(choices) {\n        return choices[Math.floor(Common.random() * choices.length)];\n    };\n\n    /**\n     * Returns true if the object is a HTMLElement, otherwise false.\n     * @method isElement\n     * @param {object} obj\n     * @return {boolean} True if the object is a HTMLElement, otherwise false\n     */\n    Common.isElement = function(obj) {\n        if (typeof HTMLElement !== 'undefined') {\n            return obj instanceof HTMLElement;\n        }\n\n        return !!(obj && obj.nodeType && obj.nodeName);\n    };\n\n    /**\n     * Returns true if the object is an array.\n     * @method isArray\n     * @param {object} obj\n     * @return {boolean} True if the object is an array, otherwise false\n     */\n    Common.isArray = function(obj) {\n        return Object.prototype.toString.call(obj) === '[object Array]';\n    };\n\n    /**\n     * Returns true if the object is a function.\n     * @method isFunction\n     * @param {object} obj\n     * @return {boolean} True if the object is a function, otherwise false\n     */\n    Common.isFunction = function(obj) {\n        return typeof obj === \"function\";\n    };\n\n    /**\n     * Returns true if the object is a plain object.\n     * @method isPlainObject\n     * @param {object} obj\n     * @return {boolean} True if the object is a plain object, otherwise false\n     */\n    Common.isPlainObject = function(obj) {\n        return typeof obj === 'object' && obj.constructor === Object;\n    };\n\n    /**\n     * Returns true if the object is a string.\n     * @method isString\n     * @param {object} obj\n     * @return {boolean} True if the object is a string, otherwise false\n     */\n    Common.isString = function(obj) {\n        return toString.call(obj) === '[object String]';\n    };\n    \n    /**\n     * Returns the given value clamped between a minimum and maximum value.\n     * @method clamp\n     * @param {number} value\n     * @param {number} min\n     * @param {number} max\n     * @return {number} The value clamped between min and max inclusive\n     */\n    Common.clamp = function(value, min, max) {\n        if (value < min)\n            return min;\n        if (value > max)\n            return max;\n        return value;\n    };\n    \n    /**\n     * Returns the sign of the given value.\n     * @method sign\n     * @param {number} value\n     * @return {number} -1 if negative, +1 if 0 or positive\n     */\n    Common.sign = function(value) {\n        return value < 0 ? -1 : 1;\n    };\n    \n    /**\n     * Returns the current timestamp since the time origin (e.g. from page load).\n     * The result will be high-resolution including decimal places if available.\n     * @method now\n     * @return {number} the current timestamp\n     */\n    Common.now = function() {\n        if (window.performance) {\n            if (window.performance.now) {\n                return window.performance.now();\n            } else if (window.performance.webkitNow) {\n                return window.performance.webkitNow();\n            }\n        }\n\n        return (new Date()) - Common._nowStartTime;\n    };\n    \n    /**\n     * Returns a random value between a minimum and a maximum value inclusive.\n     * The function uses a seeded random generator.\n     * @method random\n     * @param {number} min\n     * @param {number} max\n     * @return {number} A random number between min and max inclusive\n     */\n    Common.random = function(min, max) {\n        min = (typeof min !== \"undefined\") ? min : 0;\n        max = (typeof max !== \"undefined\") ? max : 1;\n        return min + _seededRandom() * (max - min);\n    };\n\n    var _seededRandom = function() {\n        // https://en.wikipedia.org/wiki/Linear_congruential_generator\n        Common._seed = (Common._seed * 9301 + 49297) % 233280;\n        return Common._seed / 233280;\n    };\n\n    /**\n     * Converts a CSS hex colour string into an integer.\n     * @method colorToNumber\n     * @param {string} colorString\n     * @return {number} An integer representing the CSS hex string\n     */\n    Common.colorToNumber = function(colorString) {\n        colorString = colorString.replace('#','');\n\n        if (colorString.length == 3) {\n            colorString = colorString.charAt(0) + colorString.charAt(0)\n                        + colorString.charAt(1) + colorString.charAt(1)\n                        + colorString.charAt(2) + colorString.charAt(2);\n        }\n\n        return parseInt(colorString, 16);\n    };\n\n    /**\n     * The console logging level to use, where each level includes all levels above and excludes the levels below.\n     * The default level is 'debug' which shows all console messages.  \n     *\n     * Possible level values are:\n     * - 0 = None\n     * - 1 = Debug\n     * - 2 = Info\n     * - 3 = Warn\n     * - 4 = Error\n     * @property Common.logLevel\n     * @type {Number}\n     * @default 1\n     */\n    Common.logLevel = 1;\n\n    /**\n     * Shows a `console.log` message only if the current `Common.logLevel` allows it.\n     * The message will be prefixed with 'matter-js' to make it easily identifiable.\n     * @method log\n     * @param ...objs {} The objects to log.\n     */\n    Common.log = function() {\n        if (console && Common.logLevel > 0 && Common.logLevel <= 3) {\n            console.log.apply(console, ['matter-js:'].concat(Array.prototype.slice.call(arguments)));\n        }\n    };\n\n    /**\n     * Shows a `console.info` message only if the current `Common.logLevel` allows it.\n     * The message will be prefixed with 'matter-js' to make it easily identifiable.\n     * @method info\n     * @param ...objs {} The objects to log.\n     */\n    Common.info = function() {\n        if (console && Common.logLevel > 0 && Common.logLevel <= 2) {\n            console.info.apply(console, ['matter-js:'].concat(Array.prototype.slice.call(arguments)));\n        }\n    };\n\n    /**\n     * Shows a `console.warn` message only if the current `Common.logLevel` allows it.\n     * The message will be prefixed with 'matter-js' to make it easily identifiable.\n     * @method warn\n     * @param ...objs {} The objects to log.\n     */\n    Common.warn = function() {\n        if (console && Common.logLevel > 0 && Common.logLevel <= 3) {\n            console.warn.apply(console, ['matter-js:'].concat(Array.prototype.slice.call(arguments)));\n        }\n    };\n\n    /**\n     * Returns the next unique sequential ID.\n     * @method nextId\n     * @return {Number} Unique sequential ID\n     */\n    Common.nextId = function() {\n        return Common._nextId++;\n    };\n\n    /**\n     * A cross browser compatible indexOf implementation.\n     * @method indexOf\n     * @param {array} haystack\n     * @param {object} needle\n     * @return {number} The position of needle in haystack, otherwise -1.\n     */\n    Common.indexOf = function(haystack, needle) {\n        if (haystack.indexOf)\n            return haystack.indexOf(needle);\n\n        for (var i = 0; i < haystack.length; i++) {\n            if (haystack[i] === needle)\n                return i;\n        }\n\n        return -1;\n    };\n\n    /**\n     * A cross browser compatible array map implementation.\n     * @method map\n     * @param {array} list\n     * @param {function} func\n     * @return {array} Values from list transformed by func.\n     */\n    Common.map = function(list, func) {\n        if (list.map) {\n            return list.map(func);\n        }\n\n        var mapped = [];\n\n        for (var i = 0; i < list.length; i += 1) {\n            mapped.push(func(list[i]));\n        }\n\n        return mapped;\n    };\n\n    /**\n     * Takes a directed graph and returns the partially ordered set of vertices in topological order.\n     * Circular dependencies are allowed.\n     * @method topologicalSort\n     * @param {object} graph\n     * @return {array} Partially ordered set of vertices in topological order.\n     */\n    Common.topologicalSort = function(graph) {\n        // https://github.com/mgechev/javascript-algorithms\n        // Copyright (c) Minko Gechev (MIT license)\n        // Modifications: tidy formatting and naming\n        var result = [],\n            visited = [],\n            temp = [];\n\n        for (var node in graph) {\n            if (!visited[node] && !temp[node]) {\n                Common._topologicalSort(node, visited, temp, graph, result);\n            }\n        }\n\n        return result;\n    };\n\n    Common._topologicalSort = function(node, visited, temp, graph, result) {\n        var neighbors = graph[node] || [];\n        temp[node] = true;\n\n        for (var i = 0; i < neighbors.length; i += 1) {\n            var neighbor = neighbors[i];\n\n            if (temp[neighbor]) {\n                // skip circular dependencies\n                continue;\n            }\n\n            if (!visited[neighbor]) {\n                Common._topologicalSort(neighbor, visited, temp, graph, result);\n            }\n        }\n\n        temp[node] = false;\n        visited[node] = true;\n\n        result.push(node);\n    };\n\n    /**\n     * Takes _n_ functions as arguments and returns a new function that calls them in order.\n     * The arguments applied when calling the new function will also be applied to every function passed.\n     * The value of `this` refers to the last value returned in the chain that was not `undefined`.\n     * Therefore if a passed function does not return a value, the previously returned value is maintained.\n     * After all passed functions have been called the new function returns the last returned value (if any).\n     * If any of the passed functions are a chain, then the chain will be flattened.\n     * @method chain\n     * @param ...funcs {function} The functions to chain.\n     * @return {function} A new function that calls the passed functions in order.\n     */\n    Common.chain = function() {\n        var funcs = [];\n\n        for (var i = 0; i < arguments.length; i += 1) {\n            var func = arguments[i];\n\n            if (func._chained) {\n                // flatten already chained functions\n                funcs.push.apply(funcs, func._chained);\n            } else {\n                funcs.push(func);\n            }\n        }\n\n        var chain = function() {\n            // https://github.com/GoogleChrome/devtools-docs/issues/53#issuecomment-51941358\n            var lastResult,\n                args = new Array(arguments.length);\n\n            for (var i = 0, l = arguments.length; i < l; i++) {\n                args[i] = arguments[i];\n            }\n\n            for (i = 0; i < funcs.length; i += 1) {\n                var result = funcs[i].apply(lastResult, args);\n\n                if (typeof result !== 'undefined') {\n                    lastResult = result;\n                }\n            }\n\n            return lastResult;\n        };\n\n        chain._chained = funcs;\n\n        return chain;\n    };\n\n    /**\n     * Chains a function to excute before the original function on the given `path` relative to `base`.\n     * See also docs for `Common.chain`.\n     * @method chainPathBefore\n     * @param {} base The base object\n     * @param {string} path The path relative to `base`\n     * @param {function} func The function to chain before the original\n     * @return {function} The chained function that replaced the original\n     */\n    Common.chainPathBefore = function(base, path, func) {\n        return Common.set(base, path, Common.chain(\n            func,\n            Common.get(base, path)\n        ));\n    };\n\n    /**\n     * Chains a function to excute after the original function on the given `path` relative to `base`.\n     * See also docs for `Common.chain`.\n     * @method chainPathAfter\n     * @param {} base The base object\n     * @param {string} path The path relative to `base`\n     * @param {function} func The function to chain after the original\n     * @return {function} The chained function that replaced the original\n     */\n    Common.chainPathAfter = function(base, path, func) {\n        return Common.set(base, path, Common.chain(\n            Common.get(base, path),\n            func\n        ));\n    };\n\n})();\n\n},{}],15:[function(_dereq_,module,exports){\n/**\n* The `Matter.Engine` module contains methods for creating and manipulating engines.\n* An engine is a controller that manages updating the simulation of the world.\n* See `Matter.Runner` for an optional game loop utility.\n*\n* See the included usage [examples](https://github.com/liabru/matter-js/tree/master/examples).\n*\n* @class Engine\n*/\n\nvar Engine = {};\n\nmodule.exports = Engine;\n\nvar World = _dereq_('../body/World');\nvar Sleeping = _dereq_('./Sleeping');\nvar Resolver = _dereq_('../collision/Resolver');\nvar Render = _dereq_('../render/Render');\nvar Pairs = _dereq_('../collision/Pairs');\nvar Metrics = _dereq_('./Metrics');\nvar Grid = _dereq_('../collision/Grid');\nvar Events = _dereq_('./Events');\nvar Composite = _dereq_('../body/Composite');\nvar Constraint = _dereq_('../constraint/Constraint');\nvar Common = _dereq_('./Common');\nvar Body = _dereq_('../body/Body');\n\n(function() {\n\n    /**\n     * Creates a new engine. The options parameter is an object that specifies any properties you wish to override the defaults.\n     * All properties have default values, and many are pre-calculated automatically based on other properties.\n     * See the properties section below for detailed information on what you can pass via the `options` object.\n     * @method create\n     * @param {object} [options]\n     * @return {engine} engine\n     */\n    Engine.create = function(element, options) {\n        // options may be passed as the first (and only) argument\n        options = Common.isElement(element) ? options : element;\n        element = Common.isElement(element) ? element : null;\n        options = options || {};\n\n        if (element || options.render) {\n            Common.warn('Engine.create: engine.render is deprecated (see docs)');\n        }\n\n        var defaults = {\n            positionIterations: 6,\n            velocityIterations: 4,\n            constraintIterations: 2,\n            enableSleeping: false,\n            events: [],\n            plugin: {},\n            timing: {\n                timestamp: 0,\n                timeScale: 1\n            },\n            broadphase: {\n                controller: Grid\n            }\n        };\n\n        var engine = Common.extend(defaults, options);\n\n        // @deprecated\n        if (element || engine.render) {\n            var renderDefaults = {\n                element: element,\n                controller: Render\n            };\n            \n            engine.render = Common.extend(renderDefaults, engine.render);\n        }\n\n        // @deprecated\n        if (engine.render && engine.render.controller) {\n            engine.render = engine.render.controller.create(engine.render);\n        }\n\n        // @deprecated\n        if (engine.render) {\n            engine.render.engine = engine;\n        }\n\n        engine.world = options.world || World.create(engine.world);\n        engine.pairs = Pairs.create();\n        engine.broadphase = engine.broadphase.controller.create(engine.broadphase);\n        engine.metrics = engine.metrics || { extended: false };\n\n\n        return engine;\n    };\n\n    /**\n     * Moves the simulation forward in time by `delta` ms.\n     * The `correction` argument is an optional `Number` that specifies the time correction factor to apply to the update.\n     * This can help improve the accuracy of the simulation in cases where `delta` is changing between updates.\n     * The value of `correction` is defined as `delta / lastDelta`, i.e. the percentage change of `delta` over the last step.\n     * Therefore the value is always `1` (no correction) when `delta` constant (or when no correction is desired, which is the default).\n     * See the paper on <a href=\"http://lonesock.net/article/verlet.html\">Time Corrected Verlet</a> for more information.\n     *\n     * Triggers `beforeUpdate` and `afterUpdate` events.\n     * Triggers `collisionStart`, `collisionActive` and `collisionEnd` events.\n     * @method update\n     * @param {engine} engine\n     * @param {number} [delta=16.666]\n     * @param {number} [correction=1]\n     */\n    Engine.update = function(engine, delta, correction) {\n        delta = delta || 1000 / 60;\n        correction = correction || 1;\n\n        var world = engine.world,\n            timing = engine.timing,\n            broadphase = engine.broadphase,\n            broadphasePairs = [],\n            i;\n\n        // increment timestamp\n        timing.timestamp += delta * timing.timeScale;\n\n        // create an event object\n        var event = {\n            timestamp: timing.timestamp\n        };\n\n        Events.trigger(engine, 'beforeUpdate', event);\n\n        // get lists of all bodies and constraints, no matter what composites they are in\n        var allBodies = Composite.allBodies(world),\n            allConstraints = Composite.allConstraints(world);\n\n\n        // if sleeping enabled, call the sleeping controller\n        if (engine.enableSleeping)\n            Sleeping.update(allBodies, timing.timeScale);\n\n        // applies gravity to all bodies\n        Engine._bodiesApplyGravity(allBodies, world.gravity);\n\n        // update all body position and rotation by integration\n        Engine._bodiesUpdate(allBodies, delta, timing.timeScale, correction, world.bounds);\n\n        // update all constraints (first pass)\n        Constraint.preSolveAll(allBodies);\n        for (i = 0; i < engine.constraintIterations; i++) {\n            Constraint.solveAll(allConstraints, timing.timeScale);\n        }\n        Constraint.postSolveAll(allBodies);\n\n        // broadphase pass: find potential collision pairs\n        if (broadphase.controller) {\n            // if world is dirty, we must flush the whole grid\n            if (world.isModified)\n                broadphase.controller.clear(broadphase);\n\n            // update the grid buckets based on current bodies\n            broadphase.controller.update(broadphase, allBodies, engine, world.isModified);\n            broadphasePairs = broadphase.pairsList;\n        } else {\n            // if no broadphase set, we just pass all bodies\n            broadphasePairs = allBodies;\n        }\n\n        // clear all composite modified flags\n        if (world.isModified) {\n            Composite.setModified(world, false, false, true);\n        }\n\n        // narrowphase pass: find actual collisions, then create or update collision pairs\n        var collisions = broadphase.detector(broadphasePairs, engine);\n\n        // update collision pairs\n        var pairs = engine.pairs,\n            timestamp = timing.timestamp;\n        Pairs.update(pairs, collisions, timestamp);\n        Pairs.removeOld(pairs, timestamp);\n\n        // wake up bodies involved in collisions\n        if (engine.enableSleeping)\n            Sleeping.afterCollisions(pairs.list, timing.timeScale);\n\n        // trigger collision events\n        if (pairs.collisionStart.length > 0)\n            Events.trigger(engine, 'collisionStart', { pairs: pairs.collisionStart });\n\n        // iteratively resolve position between collisions\n        Resolver.preSolvePosition(pairs.list);\n        for (i = 0; i < engine.positionIterations; i++) {\n            Resolver.solvePosition(pairs.list, timing.timeScale);\n        }\n        Resolver.postSolvePosition(allBodies);\n\n        // update all constraints (second pass)\n        Constraint.preSolveAll(allBodies);\n        for (i = 0; i < engine.constraintIterations; i++) {\n            Constraint.solveAll(allConstraints, timing.timeScale);\n        }\n        Constraint.postSolveAll(allBodies);\n\n        // iteratively resolve velocity between collisions\n        Resolver.preSolveVelocity(pairs.list);\n        for (i = 0; i < engine.velocityIterations; i++) {\n            Resolver.solveVelocity(pairs.list, timing.timeScale);\n        }\n\n        // trigger collision events\n        if (pairs.collisionActive.length > 0)\n            Events.trigger(engine, 'collisionActive', { pairs: pairs.collisionActive });\n\n        if (pairs.collisionEnd.length > 0)\n            Events.trigger(engine, 'collisionEnd', { pairs: pairs.collisionEnd });\n\n\n        // clear force buffers\n        Engine._bodiesClearForces(allBodies);\n\n        Events.trigger(engine, 'afterUpdate', event);\n\n        return engine;\n    };\n    \n    /**\n     * Merges two engines by keeping the configuration of `engineA` but replacing the world with the one from `engineB`.\n     * @method merge\n     * @param {engine} engineA\n     * @param {engine} engineB\n     */\n    Engine.merge = function(engineA, engineB) {\n        Common.extend(engineA, engineB);\n        \n        if (engineB.world) {\n            engineA.world = engineB.world;\n\n            Engine.clear(engineA);\n\n            var bodies = Composite.allBodies(engineA.world);\n\n            for (var i = 0; i < bodies.length; i++) {\n                var body = bodies[i];\n                Sleeping.set(body, false);\n                body.id = Common.nextId();\n            }\n        }\n    };\n\n    /**\n     * Clears the engine including the world, pairs and broadphase.\n     * @method clear\n     * @param {engine} engine\n     */\n    Engine.clear = function(engine) {\n        var world = engine.world;\n        \n        Pairs.clear(engine.pairs);\n\n        var broadphase = engine.broadphase;\n        if (broadphase.controller) {\n            var bodies = Composite.allBodies(world);\n            broadphase.controller.clear(broadphase);\n            broadphase.controller.update(broadphase, bodies, engine, true);\n        }\n    };\n\n    /**\n     * Zeroes the `body.force` and `body.torque` force buffers.\n     * @method _bodiesClearForces\n     * @private\n     * @param {body[]} bodies\n     */\n    Engine._bodiesClearForces = function(bodies) {\n        for (var i = 0; i < bodies.length; i++) {\n            var body = bodies[i];\n\n            // reset force buffers\n            body.force.x = 0;\n            body.force.y = 0;\n            body.torque = 0;\n        }\n    };\n\n    /**\n     * Applys a mass dependant force to all given bodies.\n     * @method _bodiesApplyGravity\n     * @private\n     * @param {body[]} bodies\n     * @param {vector} gravity\n     */\n    Engine._bodiesApplyGravity = function(bodies, gravity) {\n        var gravityScale = typeof gravity.scale !== 'undefined' ? gravity.scale : 0.001;\n\n        if ((gravity.x === 0 && gravity.y === 0) || gravityScale === 0) {\n            return;\n        }\n        \n        for (var i = 0; i < bodies.length; i++) {\n            var body = bodies[i];\n\n            if (body.isStatic || body.isSleeping)\n                continue;\n\n            // apply gravity\n            body.force.y += body.mass * gravity.y * gravityScale;\n            body.force.x += body.mass * gravity.x * gravityScale;\n        }\n    };\n\n    /**\n     * Applys `Body.update` to all given `bodies`.\n     * @method _bodiesUpdate\n     * @private\n     * @param {body[]} bodies\n     * @param {number} deltaTime \n     * The amount of time elapsed between updates\n     * @param {number} timeScale\n     * @param {number} correction \n     * The Verlet correction factor (deltaTime / lastDeltaTime)\n     * @param {bounds} worldBounds\n     */\n    Engine._bodiesUpdate = function(bodies, deltaTime, timeScale, correction, worldBounds) {\n        for (var i = 0; i < bodies.length; i++) {\n            var body = bodies[i];\n\n            if (body.isStatic || body.isSleeping)\n                continue;\n\n            Body.update(body, deltaTime, timeScale, correction);\n        }\n    };\n\n    /**\n     * An alias for `Runner.run`, see `Matter.Runner` for more information.\n     * @method run\n     * @param {engine} engine\n     */\n\n    /**\n    * Fired just before an update\n    *\n    * @event beforeUpdate\n    * @param {} event An event object\n    * @param {number} event.timestamp The engine.timing.timestamp of the event\n    * @param {} event.source The source object of the event\n    * @param {} event.name The name of the event\n    */\n\n    /**\n    * Fired after engine update and all collision events\n    *\n    * @event afterUpdate\n    * @param {} event An event object\n    * @param {number} event.timestamp The engine.timing.timestamp of the event\n    * @param {} event.source The source object of the event\n    * @param {} event.name The name of the event\n    */\n\n    /**\n    * Fired after engine update, provides a list of all pairs that have started to collide in the current tick (if any)\n    *\n    * @event collisionStart\n    * @param {} event An event object\n    * @param {} event.pairs List of affected pairs\n    * @param {number} event.timestamp The engine.timing.timestamp of the event\n    * @param {} event.source The source object of the event\n    * @param {} event.name The name of the event\n    */\n\n    /**\n    * Fired after engine update, provides a list of all pairs that are colliding in the current tick (if any)\n    *\n    * @event collisionActive\n    * @param {} event An event object\n    * @param {} event.pairs List of affected pairs\n    * @param {number} event.timestamp The engine.timing.timestamp of the event\n    * @param {} event.source The source object of the event\n    * @param {} event.name The name of the event\n    */\n\n    /**\n    * Fired after engine update, provides a list of all pairs that have ended collision in the current tick (if any)\n    *\n    * @event collisionEnd\n    * @param {} event An event object\n    * @param {} event.pairs List of affected pairs\n    * @param {number} event.timestamp The engine.timing.timestamp of the event\n    * @param {} event.source The source object of the event\n    * @param {} event.name The name of the event\n    */\n\n    /*\n    *\n    *  Properties Documentation\n    *\n    */\n\n    /**\n     * An integer `Number` that specifies the number of position iterations to perform each update.\n     * The higher the value, the higher quality the simulation will be at the expense of performance.\n     *\n     * @property positionIterations\n     * @type number\n     * @default 6\n     */\n\n    /**\n     * An integer `Number` that specifies the number of velocity iterations to perform each update.\n     * The higher the value, the higher quality the simulation will be at the expense of performance.\n     *\n     * @property velocityIterations\n     * @type number\n     * @default 4\n     */\n\n    /**\n     * An integer `Number` that specifies the number of constraint iterations to perform each update.\n     * The higher the value, the higher quality the simulation will be at the expense of performance.\n     * The default value of `2` is usually very adequate.\n     *\n     * @property constraintIterations\n     * @type number\n     * @default 2\n     */\n\n    /**\n     * A flag that specifies whether the engine should allow sleeping via the `Matter.Sleeping` module.\n     * Sleeping can improve stability and performance, but often at the expense of accuracy.\n     *\n     * @property enableSleeping\n     * @type boolean\n     * @default false\n     */\n\n    /**\n     * An `Object` containing properties regarding the timing systems of the engine. \n     *\n     * @property timing\n     * @type object\n     */\n\n    /**\n     * A `Number` that specifies the global scaling factor of time for all bodies.\n     * A value of `0` freezes the simulation.\n     * A value of `0.1` gives a slow-motion effect.\n     * A value of `1.2` gives a speed-up effect.\n     *\n     * @property timing.timeScale\n     * @type number\n     * @default 1\n     */\n\n    /**\n     * A `Number` that specifies the current simulation-time in milliseconds starting from `0`. \n     * It is incremented on every `Engine.update` by the given `delta` argument. \n     *\n     * @property timing.timestamp\n     * @type number\n     * @default 0\n     */\n\n    /**\n     * An instance of a `Render` controller. The default value is a `Matter.Render` instance created by `Engine.create`.\n     * One may also develop a custom renderer module based on `Matter.Render` and pass an instance of it to `Engine.create` via `options.render`.\n     *\n     * A minimal custom renderer object must define at least three functions: `create`, `clear` and `world` (see `Matter.Render`).\n     * It is also possible to instead pass the _module_ reference via `options.render.controller` and `Engine.create` will instantiate one for you.\n     *\n     * @property render\n     * @type render\n     * @deprecated see Demo.js for an example of creating a renderer\n     * @default a Matter.Render instance\n     */\n\n    /**\n     * An instance of a broadphase controller. The default value is a `Matter.Grid` instance created by `Engine.create`.\n     *\n     * @property broadphase\n     * @type grid\n     * @default a Matter.Grid instance\n     */\n\n    /**\n     * A `World` composite object that will contain all simulated bodies and constraints.\n     *\n     * @property world\n     * @type world\n     * @default a Matter.World instance\n     */\n\n    /**\n     * An object reserved for storing plugin-specific properties.\n     *\n     * @property plugin\n     * @type {}\n     */\n\n})();\n\n},{\"../body/Body\":1,\"../body/Composite\":2,\"../body/World\":3,\"../collision/Grid\":6,\"../collision/Pairs\":8,\"../collision/Resolver\":10,\"../constraint/Constraint\":12,\"../render/Render\":31,\"./Common\":14,\"./Events\":16,\"./Metrics\":18,\"./Sleeping\":22}],16:[function(_dereq_,module,exports){\n/**\n* The `Matter.Events` module contains methods to fire and listen to events on other objects.\n*\n* See the included usage [examples](https://github.com/liabru/matter-js/tree/master/examples).\n*\n* @class Events\n*/\n\nvar Events = {};\n\nmodule.exports = Events;\n\nvar Common = _dereq_('./Common');\n\n(function() {\n\n    /**\n     * Subscribes a callback function to the given object's `eventName`.\n     * @method on\n     * @param {} object\n     * @param {string} eventNames\n     * @param {function} callback\n     */\n    Events.on = function(object, eventNames, callback) {\n        var names = eventNames.split(' '),\n            name;\n\n        for (var i = 0; i < names.length; i++) {\n            name = names[i];\n            object.events = object.events || {};\n            object.events[name] = object.events[name] || [];\n            object.events[name].push(callback);\n        }\n\n        return callback;\n    };\n\n    /**\n     * Removes the given event callback. If no callback, clears all callbacks in `eventNames`. If no `eventNames`, clears all events.\n     * @method off\n     * @param {} object\n     * @param {string} eventNames\n     * @param {function} callback\n     */\n    Events.off = function(object, eventNames, callback) {\n        if (!eventNames) {\n            object.events = {};\n            return;\n        }\n\n        // handle Events.off(object, callback)\n        if (typeof eventNames === 'function') {\n            callback = eventNames;\n            eventNames = Common.keys(object.events).join(' ');\n        }\n\n        var names = eventNames.split(' ');\n\n        for (var i = 0; i < names.length; i++) {\n            var callbacks = object.events[names[i]],\n                newCallbacks = [];\n\n            if (callback && callbacks) {\n                for (var j = 0; j < callbacks.length; j++) {\n                    if (callbacks[j] !== callback)\n                        newCallbacks.push(callbacks[j]);\n                }\n            }\n\n            object.events[names[i]] = newCallbacks;\n        }\n    };\n\n    /**\n     * Fires all the callbacks subscribed to the given object's `eventName`, in the order they subscribed, if any.\n     * @method trigger\n     * @param {} object\n     * @param {string} eventNames\n     * @param {} event\n     */\n    Events.trigger = function(object, eventNames, event) {\n        var names,\n            name,\n            callbacks,\n            eventClone;\n\n        if (object.events) {\n            if (!event)\n                event = {};\n\n            names = eventNames.split(' ');\n\n            for (var i = 0; i < names.length; i++) {\n                name = names[i];\n                callbacks = object.events[name];\n\n                if (callbacks) {\n                    eventClone = Common.clone(event, false);\n                    eventClone.name = name;\n                    eventClone.source = object;\n\n                    for (var j = 0; j < callbacks.length; j++) {\n                        callbacks[j].apply(object, [eventClone]);\n                    }\n                }\n            }\n        }\n    };\n\n})();\n\n},{\"./Common\":14}],17:[function(_dereq_,module,exports){\n/**\n* The `Matter` module is the top level namespace. It also includes a function for installing plugins on top of the library.\n*\n* @class Matter\n*/\n\nvar Matter = {};\n\nmodule.exports = Matter;\n\nvar Plugin = _dereq_('./Plugin');\nvar Common = _dereq_('./Common');\n\n(function() {\n\n    /**\n     * The library name.\n     * @property name\n     * @readOnly\n     * @type {String}\n     */\n    Matter.name = 'matter-js';\n\n    /**\n     * The library version.\n     * @property version\n     * @readOnly\n     * @type {String}\n     */\n    Matter.version = '0.14.1';\n\n    /**\n     * A list of plugin dependencies to be installed. These are normally set and installed through `Matter.use`.\n     * Alternatively you may set `Matter.uses` manually and install them by calling `Plugin.use(Matter)`.\n     * @property uses\n     * @type {Array}\n     */\n    Matter.uses = [];\n\n    /**\n     * The plugins that have been installed through `Matter.Plugin.install`. Read only.\n     * @property used\n     * @readOnly\n     * @type {Array}\n     */\n    Matter.used = [];\n\n    /**\n     * Installs the given plugins on the `Matter` namespace.\n     * This is a short-hand for `Plugin.use`, see it for more information.\n     * Call this function once at the start of your code, with all of the plugins you wish to install as arguments.\n     * Avoid calling this function multiple times unless you intend to manually control installation order.\n     * @method use\n     * @param ...plugin {Function} The plugin(s) to install on `base` (multi-argument).\n     */\n    Matter.use = function() {\n        Plugin.use(Matter, Array.prototype.slice.call(arguments));\n    };\n\n    /**\n     * Chains a function to excute before the original function on the given `path` relative to `Matter`.\n     * See also docs for `Common.chain`.\n     * @method before\n     * @param {string} path The path relative to `Matter`\n     * @param {function} func The function to chain before the original\n     * @return {function} The chained function that replaced the original\n     */\n    Matter.before = function(path, func) {\n        path = path.replace(/^Matter./, '');\n        return Common.chainPathBefore(Matter, path, func);\n    };\n\n    /**\n     * Chains a function to excute after the original function on the given `path` relative to `Matter`.\n     * See also docs for `Common.chain`.\n     * @method after\n     * @param {string} path The path relative to `Matter`\n     * @param {function} func The function to chain after the original\n     * @return {function} The chained function that replaced the original\n     */\n    Matter.after = function(path, func) {\n        path = path.replace(/^Matter./, '');\n        return Common.chainPathAfter(Matter, path, func);\n    };\n\n})();\n\n},{\"./Common\":14,\"./Plugin\":20}],18:[function(_dereq_,module,exports){\n\n},{\"../body/Composite\":2,\"./Common\":14}],19:[function(_dereq_,module,exports){\n/**\n* The `Matter.Mouse` module contains methods for creating and manipulating mouse inputs.\n*\n* @class Mouse\n*/\n\nvar Mouse = {};\n\nmodule.exports = Mouse;\n\nvar Common = _dereq_('../core/Common');\n\n(function() {\n\n    /**\n     * Creates a mouse input.\n     * @method create\n     * @param {HTMLElement} element\n     * @return {mouse} A new mouse\n     */\n    Mouse.create = function(element) {\n        var mouse = {};\n\n        if (!element) {\n            Common.log('Mouse.create: element was undefined, defaulting to document.body', 'warn');\n        }\n        \n        mouse.element = element || document.body;\n        mouse.absolute = { x: 0, y: 0 };\n        mouse.position = { x: 0, y: 0 };\n        mouse.mousedownPosition = { x: 0, y: 0 };\n        mouse.mouseupPosition = { x: 0, y: 0 };\n        mouse.offset = { x: 0, y: 0 };\n        mouse.scale = { x: 1, y: 1 };\n        mouse.wheelDelta = 0;\n        mouse.button = -1;\n        mouse.pixelRatio = mouse.element.getAttribute('data-pixel-ratio') || 1;\n\n        mouse.sourceEvents = {\n            mousemove: null,\n            mousedown: null,\n            mouseup: null,\n            mousewheel: null\n        };\n        \n        mouse.mousemove = function(event) { \n            var position = Mouse._getRelativeMousePosition(event, mouse.element, mouse.pixelRatio),\n                touches = event.changedTouches;\n\n            if (touches) {\n                mouse.button = 0;\n                event.preventDefault();\n            }\n\n            mouse.absolute.x = position.x;\n            mouse.absolute.y = position.y;\n            mouse.position.x = mouse.absolute.x * mouse.scale.x + mouse.offset.x;\n            mouse.position.y = mouse.absolute.y * mouse.scale.y + mouse.offset.y;\n            mouse.sourceEvents.mousemove = event;\n        };\n        \n        mouse.mousedown = function(event) {\n            var position = Mouse._getRelativeMousePosition(event, mouse.element, mouse.pixelRatio),\n                touches = event.changedTouches;\n\n            if (touches) {\n                mouse.button = 0;\n                event.preventDefault();\n            } else {\n                mouse.button = event.button;\n            }\n\n            mouse.absolute.x = position.x;\n            mouse.absolute.y = position.y;\n            mouse.position.x = mouse.absolute.x * mouse.scale.x + mouse.offset.x;\n            mouse.position.y = mouse.absolute.y * mouse.scale.y + mouse.offset.y;\n            mouse.mousedownPosition.x = mouse.position.x;\n            mouse.mousedownPosition.y = mouse.position.y;\n            mouse.sourceEvents.mousedown = event;\n        };\n        \n        mouse.mouseup = function(event) {\n            var position = Mouse._getRelativeMousePosition(event, mouse.element, mouse.pixelRatio),\n                touches = event.changedTouches;\n\n            if (touches) {\n                event.preventDefault();\n            }\n            \n            mouse.button = -1;\n            mouse.absolute.x = position.x;\n            mouse.absolute.y = position.y;\n            mouse.position.x = mouse.absolute.x * mouse.scale.x + mouse.offset.x;\n            mouse.position.y = mouse.absolute.y * mouse.scale.y + mouse.offset.y;\n            mouse.mouseupPosition.x = mouse.position.x;\n            mouse.mouseupPosition.y = mouse.position.y;\n            mouse.sourceEvents.mouseup = event;\n        };\n\n        mouse.mousewheel = function(event) {\n            mouse.wheelDelta = Math.max(-1, Math.min(1, event.wheelDelta || -event.detail));\n            event.preventDefault();\n        };\n\n        Mouse.setElement(mouse, mouse.element);\n\n        return mouse;\n    };\n\n    /**\n     * Sets the element the mouse is bound to (and relative to).\n     * @method setElement\n     * @param {mouse} mouse\n     * @param {HTMLElement} element\n     */\n    Mouse.setElement = function(mouse, element) {\n        mouse.element = element;\n\n        element.addEventListener('mousemove', mouse.mousemove);\n        element.addEventListener('mousedown', mouse.mousedown);\n        element.addEventListener('mouseup', mouse.mouseup);\n        \n        element.addEventListener('mousewheel', mouse.mousewheel);\n        element.addEventListener('DOMMouseScroll', mouse.mousewheel);\n\n        element.addEventListener('touchmove', mouse.mousemove);\n        element.addEventListener('touchstart', mouse.mousedown);\n        element.addEventListener('touchend', mouse.mouseup);\n    };\n\n    /**\n     * Clears all captured source events.\n     * @method clearSourceEvents\n     * @param {mouse} mouse\n     */\n    Mouse.clearSourceEvents = function(mouse) {\n        mouse.sourceEvents.mousemove = null;\n        mouse.sourceEvents.mousedown = null;\n        mouse.sourceEvents.mouseup = null;\n        mouse.sourceEvents.mousewheel = null;\n        mouse.wheelDelta = 0;\n    };\n\n    /**\n     * Sets the mouse position offset.\n     * @method setOffset\n     * @param {mouse} mouse\n     * @param {vector} offset\n     */\n    Mouse.setOffset = function(mouse, offset) {\n        mouse.offset.x = offset.x;\n        mouse.offset.y = offset.y;\n        mouse.position.x = mouse.absolute.x * mouse.scale.x + mouse.offset.x;\n        mouse.position.y = mouse.absolute.y * mouse.scale.y + mouse.offset.y;\n    };\n\n    /**\n     * Sets the mouse position scale.\n     * @method setScale\n     * @param {mouse} mouse\n     * @param {vector} scale\n     */\n    Mouse.setScale = function(mouse, scale) {\n        mouse.scale.x = scale.x;\n        mouse.scale.y = scale.y;\n        mouse.position.x = mouse.absolute.x * mouse.scale.x + mouse.offset.x;\n        mouse.position.y = mouse.absolute.y * mouse.scale.y + mouse.offset.y;\n    };\n    \n    /**\n     * Gets the mouse position relative to an element given a screen pixel ratio.\n     * @method _getRelativeMousePosition\n     * @private\n     * @param {} event\n     * @param {} element\n     * @param {number} pixelRatio\n     * @return {}\n     */\n    Mouse._getRelativeMousePosition = function(event, element, pixelRatio) {\n        var elementBounds = element.getBoundingClientRect(),\n            rootNode = (document.documentElement || document.body.parentNode || document.body),\n            scrollX = (window.pageXOffset !== undefined) ? window.pageXOffset : rootNode.scrollLeft,\n            scrollY = (window.pageYOffset !== undefined) ? window.pageYOffset : rootNode.scrollTop,\n            touches = event.changedTouches,\n            x, y;\n        \n        if (touches) {\n            x = touches[0].pageX - elementBounds.left - scrollX;\n            y = touches[0].pageY - elementBounds.top - scrollY;\n        } else {\n            x = event.pageX - elementBounds.left - scrollX;\n            y = event.pageY - elementBounds.top - scrollY;\n        }\n\n        return { \n            x: x / (element.clientWidth / (element.width || element.clientWidth) * pixelRatio),\n            y: y / (element.clientHeight / (element.height || element.clientHeight) * pixelRatio)\n        };\n    };\n\n})();\n\n},{\"../core/Common\":14}],20:[function(_dereq_,module,exports){\n/**\n* The `Matter.Plugin` module contains functions for registering and installing plugins on modules.\n*\n* @class Plugin\n*/\n\nvar Plugin = {};\n\nmodule.exports = Plugin;\n\nvar Common = _dereq_('./Common');\n\n(function() {\n\n    Plugin._registry = {};\n\n    /**\n     * Registers a plugin object so it can be resolved later by name.\n     * @method register\n     * @param plugin {} The plugin to register.\n     * @return {object} The plugin.\n     */\n    Plugin.register = function(plugin) {\n        if (!Plugin.isPlugin(plugin)) {\n            Common.warn('Plugin.register:', Plugin.toString(plugin), 'does not implement all required fields.');\n        }\n\n        if (plugin.name in Plugin._registry) {\n            var registered = Plugin._registry[plugin.name],\n                pluginVersion = Plugin.versionParse(plugin.version).number,\n                registeredVersion = Plugin.versionParse(registered.version).number;\n\n            if (pluginVersion > registeredVersion) {\n                Common.warn('Plugin.register:', Plugin.toString(registered), 'was upgraded to', Plugin.toString(plugin));\n                Plugin._registry[plugin.name] = plugin;\n            } else if (pluginVersion < registeredVersion) {\n                Common.warn('Plugin.register:', Plugin.toString(registered), 'can not be downgraded to', Plugin.toString(plugin));\n            } else if (plugin !== registered) {\n                Common.warn('Plugin.register:', Plugin.toString(plugin), 'is already registered to different plugin object');\n            }\n        } else {\n            Plugin._registry[plugin.name] = plugin;\n        }\n\n        return plugin;\n    };\n\n    /**\n     * Resolves a dependency to a plugin object from the registry if it exists. \n     * The `dependency` may contain a version, but only the name matters when resolving.\n     * @method resolve\n     * @param dependency {string} The dependency.\n     * @return {object} The plugin if resolved, otherwise `undefined`.\n     */\n    Plugin.resolve = function(dependency) {\n        return Plugin._registry[Plugin.dependencyParse(dependency).name];\n    };\n\n    /**\n     * Returns a pretty printed plugin name and version.\n     * @method toString\n     * @param plugin {} The plugin.\n     * @return {string} Pretty printed plugin name and version.\n     */\n    Plugin.toString = function(plugin) {\n        return typeof plugin === 'string' ? plugin : (plugin.name || 'anonymous') + '@' + (plugin.version || plugin.range || '0.0.0');\n    };\n\n    /**\n     * Returns `true` if the object meets the minimum standard to be considered a plugin.\n     * This means it must define the following properties:\n     * - `name`\n     * - `version`\n     * - `install`\n     * @method isPlugin\n     * @param obj {} The obj to test.\n     * @return {boolean} `true` if the object can be considered a plugin otherwise `false`.\n     */\n    Plugin.isPlugin = function(obj) {\n        return obj && obj.name && obj.version && obj.install;\n    };\n\n    /**\n     * Returns `true` if a plugin with the given `name` been installed on `module`.\n     * @method isUsed\n     * @param module {} The module.\n     * @param name {string} The plugin name.\n     * @return {boolean} `true` if a plugin with the given `name` been installed on `module`, otherwise `false`.\n     */\n    Plugin.isUsed = function(module, name) {\n        return module.used.indexOf(name) > -1;\n    };\n\n    /**\n     * Returns `true` if `plugin.for` is applicable to `module` by comparing against `module.name` and `module.version`.\n     * If `plugin.for` is not specified then it is assumed to be applicable.\n     * The value of `plugin.for` is a string of the format `'module-name'` or `'module-name@version'`.\n     * @method isFor\n     * @param plugin {} The plugin.\n     * @param module {} The module.\n     * @return {boolean} `true` if `plugin.for` is applicable to `module`, otherwise `false`.\n     */\n    Plugin.isFor = function(plugin, module) {\n        var parsed = plugin.for && Plugin.dependencyParse(plugin.for);\n        return !plugin.for || (module.name === parsed.name && Plugin.versionSatisfies(module.version, parsed.range));\n    };\n\n    /**\n     * Installs the plugins by calling `plugin.install` on each plugin specified in `plugins` if passed, otherwise `module.uses`.\n     * For installing plugins on `Matter` see the convenience function `Matter.use`.\n     * Plugins may be specified either by their name or a reference to the plugin object.\n     * Plugins themselves may specify further dependencies, but each plugin is installed only once.\n     * Order is important, a topological sort is performed to find the best resulting order of installation.\n     * This sorting attempts to satisfy every dependency's requested ordering, but may not be exact in all cases.\n     * This function logs the resulting status of each dependency in the console, along with any warnings.\n     * - A green tick ✅ indicates a dependency was resolved and installed.\n     * - An orange diamond 🔶 indicates a dependency was resolved but a warning was thrown for it or one if its dependencies.\n     * - A red cross ❌ indicates a dependency could not be resolved.\n     * Avoid calling this function multiple times on the same module unless you intend to manually control installation order.\n     * @method use\n     * @param module {} The module install plugins on.\n     * @param [plugins=module.uses] {} The plugins to install on module (optional, defaults to `module.uses`).\n     */\n    Plugin.use = function(module, plugins) {\n        module.uses = (module.uses || []).concat(plugins || []);\n\n        if (module.uses.length === 0) {\n            Common.warn('Plugin.use:', Plugin.toString(module), 'does not specify any dependencies to install.');\n            return;\n        }\n\n        var dependencies = Plugin.dependencies(module),\n            sortedDependencies = Common.topologicalSort(dependencies),\n            status = [];\n\n        for (var i = 0; i < sortedDependencies.length; i += 1) {\n            if (sortedDependencies[i] === module.name) {\n                continue;\n            }\n\n            var plugin = Plugin.resolve(sortedDependencies[i]);\n\n            if (!plugin) {\n                status.push('❌ ' + sortedDependencies[i]);\n                continue;\n            }\n\n            if (Plugin.isUsed(module, plugin.name)) {\n                continue;\n            }\n\n            if (!Plugin.isFor(plugin, module)) {\n                Common.warn('Plugin.use:', Plugin.toString(plugin), 'is for', plugin.for, 'but installed on', Plugin.toString(module) + '.');\n                plugin._warned = true;\n            }\n\n            if (plugin.install) {\n                plugin.install(module);\n            } else {\n                Common.warn('Plugin.use:', Plugin.toString(plugin), 'does not specify an install function.');\n                plugin._warned = true;\n            }\n\n            if (plugin._warned) {\n                status.push('🔶 ' + Plugin.toString(plugin));\n                delete plugin._warned;\n            } else {\n                status.push('✅ ' + Plugin.toString(plugin));\n            }\n\n            module.used.push(plugin.name);\n        }\n\n        if (status.length > 0) {\n            Common.info(status.join('  '));\n        }\n    };\n\n    /**\n     * Recursively finds all of a module's dependencies and returns a flat dependency graph.\n     * @method dependencies\n     * @param module {} The module.\n     * @return {object} A dependency graph.\n     */\n    Plugin.dependencies = function(module, tracked) {\n        var parsedBase = Plugin.dependencyParse(module),\n            name = parsedBase.name;\n\n        tracked = tracked || {};\n\n        if (name in tracked) {\n            return;\n        }\n\n        module = Plugin.resolve(module) || module;\n\n        tracked[name] = Common.map(module.uses || [], function(dependency) {\n            if (Plugin.isPlugin(dependency)) {\n                Plugin.register(dependency);\n            }\n\n            var parsed = Plugin.dependencyParse(dependency),\n                resolved = Plugin.resolve(dependency);\n\n            if (resolved && !Plugin.versionSatisfies(resolved.version, parsed.range)) {\n                Common.warn(\n                    'Plugin.dependencies:', Plugin.toString(resolved), 'does not satisfy',\n                    Plugin.toString(parsed), 'used by', Plugin.toString(parsedBase) + '.'\n                );\n\n                resolved._warned = true;\n                module._warned = true;\n            } else if (!resolved) {\n                Common.warn(\n                    'Plugin.dependencies:', Plugin.toString(dependency), 'used by',\n                    Plugin.toString(parsedBase), 'could not be resolved.'\n                );\n\n                module._warned = true;\n            }\n\n            return parsed.name;\n        });\n\n        for (var i = 0; i < tracked[name].length; i += 1) {\n            Plugin.dependencies(tracked[name][i], tracked);\n        }\n\n        return tracked;\n    };\n\n    /**\n     * Parses a dependency string into its components.\n     * The `dependency` is a string of the format `'module-name'` or `'module-name@version'`.\n     * See documentation for `Plugin.versionParse` for a description of the format.\n     * This function can also handle dependencies that are already resolved (e.g. a module object).\n     * @method dependencyParse\n     * @param dependency {string} The dependency of the format `'module-name'` or `'module-name@version'`.\n     * @return {object} The dependency parsed into its components.\n     */\n    Plugin.dependencyParse = function(dependency) {\n        if (Common.isString(dependency)) {\n            var pattern = /^[\\w-]+(@(\\*|[\\^~]?\\d+\\.\\d+\\.\\d+(-[0-9A-Za-z-]+)?))?$/;\n\n            if (!pattern.test(dependency)) {\n                Common.warn('Plugin.dependencyParse:', dependency, 'is not a valid dependency string.');\n            }\n\n            return {\n                name: dependency.split('@')[0],\n                range: dependency.split('@')[1] || '*'\n            };\n        }\n\n        return {\n            name: dependency.name,\n            range: dependency.range || dependency.version\n        };\n    };\n\n    /**\n     * Parses a version string into its components.  \n     * Versions are strictly of the format `x.y.z` (as in [semver](http://semver.org/)).\n     * Versions may optionally have a prerelease tag in the format `x.y.z-alpha`.\n     * Ranges are a strict subset of [npm ranges](https://docs.npmjs.com/misc/semver#advanced-range-syntax).\n     * Only the following range types are supported:\n     * - Tilde ranges e.g. `~1.2.3`\n     * - Caret ranges e.g. `^1.2.3`\n     * - Exact version e.g. `1.2.3`\n     * - Any version `*`\n     * @method versionParse\n     * @param range {string} The version string.\n     * @return {object} The version range parsed into its components.\n     */\n    Plugin.versionParse = function(range) {\n        var pattern = /^\\*|[\\^~]?\\d+\\.\\d+\\.\\d+(-[0-9A-Za-z-]+)?$/;\n\n        if (!pattern.test(range)) {\n            Common.warn('Plugin.versionParse:', range, 'is not a valid version or range.');\n        }\n\n        var identifiers = range.split('-');\n        range = identifiers[0];\n\n        var isRange = isNaN(Number(range[0])),\n            version = isRange ? range.substr(1) : range,\n            parts = Common.map(version.split('.'), function(part) {\n                return Number(part);\n            });\n\n        return {\n            isRange: isRange,\n            version: version,\n            range: range,\n            operator: isRange ? range[0] : '',\n            parts: parts,\n            prerelease: identifiers[1],\n            number: parts[0] * 1e8 + parts[1] * 1e4 + parts[2]\n        };\n    };\n\n    /**\n     * Returns `true` if `version` satisfies the given `range`.\n     * See documentation for `Plugin.versionParse` for a description of the format.\n     * If a version or range is not specified, then any version (`*`) is assumed to satisfy.\n     * @method versionSatisfies\n     * @param version {string} The version string.\n     * @param range {string} The range string.\n     * @return {boolean} `true` if `version` satisfies `range`, otherwise `false`.\n     */\n    Plugin.versionSatisfies = function(version, range) {\n        range = range || '*';\n\n        var rangeParsed = Plugin.versionParse(range),\n            rangeParts = rangeParsed.parts,\n            versionParsed = Plugin.versionParse(version),\n            versionParts = versionParsed.parts;\n\n        if (rangeParsed.isRange) {\n            if (rangeParsed.operator === '*' || version === '*') {\n                return true;\n            }\n\n            if (rangeParsed.operator === '~') {\n                return versionParts[0] === rangeParts[0] && versionParts[1] === rangeParts[1] && versionParts[2] >= rangeParts[2];\n            }\n\n            if (rangeParsed.operator === '^') {\n                if (rangeParts[0] > 0) {\n                    return versionParts[0] === rangeParts[0] && versionParsed.number >= rangeParsed.number;\n                }\n\n                if (rangeParts[1] > 0) {\n                    return versionParts[1] === rangeParts[1] && versionParts[2] >= rangeParts[2];\n                }\n\n                return versionParts[2] === rangeParts[2];\n            }\n        }\n\n        return version === range || version === '*';\n    };\n\n})();\n\n},{\"./Common\":14}],21:[function(_dereq_,module,exports){\n/**\n* The `Matter.Runner` module is an optional utility which provides a game loop, \n* that handles continuously updating a `Matter.Engine` for you within a browser.\n* It is intended for development and debugging purposes, but may also be suitable for simple games.\n* If you are using your own game loop instead, then you do not need the `Matter.Runner` module.\n* Instead just call `Engine.update(engine, delta)` in your own loop.\n*\n* See the included usage [examples](https://github.com/liabru/matter-js/tree/master/examples).\n*\n* @class Runner\n*/\n\nvar Runner = {};\n\nmodule.exports = Runner;\n\nvar Events = _dereq_('./Events');\nvar Engine = _dereq_('./Engine');\nvar Common = _dereq_('./Common');\n\n(function() {\n\n    var _requestAnimationFrame,\n        _cancelAnimationFrame;\n\n    if (typeof window !== 'undefined') {\n        _requestAnimationFrame = window.requestAnimationFrame || window.webkitRequestAnimationFrame\n                                      || window.mozRequestAnimationFrame || window.msRequestAnimationFrame;\n   \n        _cancelAnimationFrame = window.cancelAnimationFrame || window.mozCancelAnimationFrame \n                                      || window.webkitCancelAnimationFrame || window.msCancelAnimationFrame;\n    }\n\n    if (!_requestAnimationFrame) {\n        var _frameTimeout;\n\n        _requestAnimationFrame = function(callback){ \n            _frameTimeout = setTimeout(function() { \n                callback(Common.now()); \n            }, 1000 / 60);\n        };\n\n        _cancelAnimationFrame = function() {\n            clearTimeout(_frameTimeout);\n        };\n    }\n\n    /**\n     * Creates a new Runner. The options parameter is an object that specifies any properties you wish to override the defaults.\n     * @method create\n     * @param {} options\n     */\n    Runner.create = function(options) {\n        var defaults = {\n            fps: 60,\n            correction: 1,\n            deltaSampleSize: 60,\n            counterTimestamp: 0,\n            frameCounter: 0,\n            deltaHistory: [],\n            timePrev: null,\n            timeScalePrev: 1,\n            frameRequestId: null,\n            isFixed: false,\n            enabled: true\n        };\n\n        var runner = Common.extend(defaults, options);\n\n        runner.delta = runner.delta || 1000 / runner.fps;\n        runner.deltaMin = runner.deltaMin || 1000 / runner.fps;\n        runner.deltaMax = runner.deltaMax || 1000 / (runner.fps * 0.5);\n        runner.fps = 1000 / runner.delta;\n\n        return runner;\n    };\n\n    /**\n     * Continuously ticks a `Matter.Engine` by calling `Runner.tick` on the `requestAnimationFrame` event.\n     * @method run\n     * @param {engine} engine\n     */\n    Runner.run = function(runner, engine) {\n        // create runner if engine is first argument\n        if (typeof runner.positionIterations !== 'undefined') {\n            engine = runner;\n            runner = Runner.create();\n        }\n\n        (function render(time){\n            runner.frameRequestId = _requestAnimationFrame(render);\n\n            if (time && runner.enabled) {\n                Runner.tick(runner, engine, time);\n            }\n        })();\n\n        return runner;\n    };\n\n    /**\n     * A game loop utility that updates the engine and renderer by one step (a 'tick').\n     * Features delta smoothing, time correction and fixed or dynamic timing.\n     * Triggers `beforeTick`, `tick` and `afterTick` events on the engine.\n     * Consider just `Engine.update(engine, delta)` if you're using your own loop.\n     * @method tick\n     * @param {runner} runner\n     * @param {engine} engine\n     * @param {number} time\n     */\n    Runner.tick = function(runner, engine, time) {\n        var timing = engine.timing,\n            correction = 1,\n            delta;\n\n        // create an event object\n        var event = {\n            timestamp: timing.timestamp\n        };\n\n        Events.trigger(runner, 'beforeTick', event);\n        Events.trigger(engine, 'beforeTick', event); // @deprecated\n\n        if (runner.isFixed) {\n            // fixed timestep\n            delta = runner.delta;\n        } else {\n            // dynamic timestep based on wall clock between calls\n            delta = (time - runner.timePrev) || runner.delta;\n            runner.timePrev = time;\n\n            // optimistically filter delta over a few frames, to improve stability\n            runner.deltaHistory.push(delta);\n            runner.deltaHistory = runner.deltaHistory.slice(-runner.deltaSampleSize);\n            delta = Math.min.apply(null, runner.deltaHistory);\n            \n            // limit delta\n            delta = delta < runner.deltaMin ? runner.deltaMin : delta;\n            delta = delta > runner.deltaMax ? runner.deltaMax : delta;\n\n            // correction for delta\n            correction = delta / runner.delta;\n\n            // update engine timing object\n            runner.delta = delta;\n        }\n\n        // time correction for time scaling\n        if (runner.timeScalePrev !== 0)\n            correction *= timing.timeScale / runner.timeScalePrev;\n\n        if (timing.timeScale === 0)\n            correction = 0;\n\n        runner.timeScalePrev = timing.timeScale;\n        runner.correction = correction;\n\n        // fps counter\n        runner.frameCounter += 1;\n        if (time - runner.counterTimestamp >= 1000) {\n            runner.fps = runner.frameCounter * ((time - runner.counterTimestamp) / 1000);\n            runner.counterTimestamp = time;\n            runner.frameCounter = 0;\n        }\n\n        Events.trigger(runner, 'tick', event);\n        Events.trigger(engine, 'tick', event); // @deprecated\n\n        // if world has been modified, clear the render scene graph\n        if (engine.world.isModified \n            && engine.render\n            && engine.render.controller\n            && engine.render.controller.clear) {\n            engine.render.controller.clear(engine.render); // @deprecated\n        }\n\n        // update\n        Events.trigger(runner, 'beforeUpdate', event);\n        Engine.update(engine, delta, correction);\n        Events.trigger(runner, 'afterUpdate', event);\n\n        // render\n        // @deprecated\n        if (engine.render && engine.render.controller) {\n            Events.trigger(runner, 'beforeRender', event);\n            Events.trigger(engine, 'beforeRender', event); // @deprecated\n\n            engine.render.controller.world(engine.render);\n\n            Events.trigger(runner, 'afterRender', event);\n            Events.trigger(engine, 'afterRender', event); // @deprecated\n        }\n\n        Events.trigger(runner, 'afterTick', event);\n        Events.trigger(engine, 'afterTick', event); // @deprecated\n    };\n\n    /**\n     * Ends execution of `Runner.run` on the given `runner`, by canceling the animation frame request event loop.\n     * If you wish to only temporarily pause the engine, see `engine.enabled` instead.\n     * @method stop\n     * @param {runner} runner\n     */\n    Runner.stop = function(runner) {\n        _cancelAnimationFrame(runner.frameRequestId);\n    };\n\n    /**\n     * Alias for `Runner.run`.\n     * @method start\n     * @param {runner} runner\n     * @param {engine} engine\n     */\n    Runner.start = function(runner, engine) {\n        Runner.run(runner, engine);\n    };\n\n    /*\n    *\n    *  Events Documentation\n    *\n    */\n\n    /**\n    * Fired at the start of a tick, before any updates to the engine or timing\n    *\n    * @event beforeTick\n    * @param {} event An event object\n    * @param {number} event.timestamp The engine.timing.timestamp of the event\n    * @param {} event.source The source object of the event\n    * @param {} event.name The name of the event\n    */\n\n    /**\n    * Fired after engine timing updated, but just before update\n    *\n    * @event tick\n    * @param {} event An event object\n    * @param {number} event.timestamp The engine.timing.timestamp of the event\n    * @param {} event.source The source object of the event\n    * @param {} event.name The name of the event\n    */\n\n    /**\n    * Fired at the end of a tick, after engine update and after rendering\n    *\n    * @event afterTick\n    * @param {} event An event object\n    * @param {number} event.timestamp The engine.timing.timestamp of the event\n    * @param {} event.source The source object of the event\n    * @param {} event.name The name of the event\n    */\n\n    /**\n    * Fired before update\n    *\n    * @event beforeUpdate\n    * @param {} event An event object\n    * @param {number} event.timestamp The engine.timing.timestamp of the event\n    * @param {} event.source The source object of the event\n    * @param {} event.name The name of the event\n    */\n\n    /**\n    * Fired after update\n    *\n    * @event afterUpdate\n    * @param {} event An event object\n    * @param {number} event.timestamp The engine.timing.timestamp of the event\n    * @param {} event.source The source object of the event\n    * @param {} event.name The name of the event\n    */\n\n    /**\n    * Fired before rendering\n    *\n    * @event beforeRender\n    * @param {} event An event object\n    * @param {number} event.timestamp The engine.timing.timestamp of the event\n    * @param {} event.source The source object of the event\n    * @param {} event.name The name of the event\n    * @deprecated\n    */\n\n    /**\n    * Fired after rendering\n    *\n    * @event afterRender\n    * @param {} event An event object\n    * @param {number} event.timestamp The engine.timing.timestamp of the event\n    * @param {} event.source The source object of the event\n    * @param {} event.name The name of the event\n    * @deprecated\n    */\n\n    /*\n    *\n    *  Properties Documentation\n    *\n    */\n\n    /**\n     * A flag that specifies whether the runner is running or not.\n     *\n     * @property enabled\n     * @type boolean\n     * @default true\n     */\n\n    /**\n     * A `Boolean` that specifies if the runner should use a fixed timestep (otherwise it is variable).\n     * If timing is fixed, then the apparent simulation speed will change depending on the frame rate (but behaviour will be deterministic).\n     * If the timing is variable, then the apparent simulation speed will be constant (approximately, but at the cost of determininism).\n     *\n     * @property isFixed\n     * @type boolean\n     * @default false\n     */\n\n    /**\n     * A `Number` that specifies the time step between updates in milliseconds.\n     * If `engine.timing.isFixed` is set to `true`, then `delta` is fixed.\n     * If it is `false`, then `delta` can dynamically change to maintain the correct apparent simulation speed.\n     *\n     * @property delta\n     * @type number\n     * @default 1000 / 60\n     */\n\n})();\n\n},{\"./Common\":14,\"./Engine\":15,\"./Events\":16}],22:[function(_dereq_,module,exports){\n/**\n* The `Matter.Sleeping` module contains methods to manage the sleeping state of bodies.\n*\n* @class Sleeping\n*/\n\nvar Sleeping = {};\n\nmodule.exports = Sleeping;\n\nvar Events = _dereq_('./Events');\n\n(function() {\n\n    Sleeping._motionWakeThreshold = 0.18;\n    Sleeping._motionSleepThreshold = 0.08;\n    Sleeping._minBias = 0.9;\n\n    /**\n     * Puts bodies to sleep or wakes them up depending on their motion.\n     * @method update\n     * @param {body[]} bodies\n     * @param {number} timeScale\n     */\n    Sleeping.update = function(bodies, timeScale) {\n        var timeFactor = timeScale * timeScale * timeScale;\n\n        // update bodies sleeping status\n        for (var i = 0; i < bodies.length; i++) {\n            var body = bodies[i],\n                motion = body.speed * body.speed + body.angularSpeed * body.angularSpeed;\n\n            // wake up bodies if they have a force applied\n            if (body.force.x !== 0 || body.force.y !== 0) {\n                Sleeping.set(body, false);\n                continue;\n            }\n\n            var minMotion = Math.min(body.motion, motion),\n                maxMotion = Math.max(body.motion, motion);\n        \n            // biased average motion estimation between frames\n            body.motion = Sleeping._minBias * minMotion + (1 - Sleeping._minBias) * maxMotion;\n            \n            if (body.sleepThreshold > 0 && body.motion < Sleeping._motionSleepThreshold * timeFactor) {\n                body.sleepCounter += 1;\n                \n                if (body.sleepCounter >= body.sleepThreshold)\n                    Sleeping.set(body, true);\n            } else if (body.sleepCounter > 0) {\n                body.sleepCounter -= 1;\n            }\n        }\n    };\n\n    /**\n     * Given a set of colliding pairs, wakes the sleeping bodies involved.\n     * @method afterCollisions\n     * @param {pair[]} pairs\n     * @param {number} timeScale\n     */\n    Sleeping.afterCollisions = function(pairs, timeScale) {\n        var timeFactor = timeScale * timeScale * timeScale;\n\n        // wake up bodies involved in collisions\n        for (var i = 0; i < pairs.length; i++) {\n            var pair = pairs[i];\n            \n            // don't wake inactive pairs\n            if (!pair.isActive)\n                continue;\n\n            var collision = pair.collision,\n                bodyA = collision.bodyA.parent, \n                bodyB = collision.bodyB.parent;\n        \n            // don't wake if at least one body is static\n            if ((bodyA.isSleeping && bodyB.isSleeping) || bodyA.isStatic || bodyB.isStatic)\n                continue;\n        \n            if (bodyA.isSleeping || bodyB.isSleeping) {\n                var sleepingBody = (bodyA.isSleeping && !bodyA.isStatic) ? bodyA : bodyB,\n                    movingBody = sleepingBody === bodyA ? bodyB : bodyA;\n\n                if (!sleepingBody.isStatic && movingBody.motion > Sleeping._motionWakeThreshold * timeFactor) {\n                    Sleeping.set(sleepingBody, false);\n                }\n            }\n        }\n    };\n  \n    /**\n     * Set a body as sleeping or awake.\n     * @method set\n     * @param {body} body\n     * @param {boolean} isSleeping\n     */\n    Sleeping.set = function(body, isSleeping) {\n        var wasSleeping = body.isSleeping;\n\n        if (isSleeping) {\n            body.isSleeping = true;\n            body.sleepCounter = body.sleepThreshold;\n\n            body.positionImpulse.x = 0;\n            body.positionImpulse.y = 0;\n\n            body.positionPrev.x = body.position.x;\n            body.positionPrev.y = body.position.y;\n\n            body.anglePrev = body.angle;\n            body.speed = 0;\n            body.angularSpeed = 0;\n            body.motion = 0;\n\n            if (!wasSleeping) {\n                Events.trigger(body, 'sleepStart');\n            }\n        } else {\n            body.isSleeping = false;\n            body.sleepCounter = 0;\n\n            if (wasSleeping) {\n                Events.trigger(body, 'sleepEnd');\n            }\n        }\n    };\n\n})();\n\n},{\"./Events\":16}],23:[function(_dereq_,module,exports){\n(function (global){\n/**\n* The `Matter.Bodies` module contains factory methods for creating rigid body models \n* with commonly used body configurations (such as rectangles, circles and other polygons).\n*\n* See the included usage [examples](https://github.com/liabru/matter-js/tree/master/examples).\n*\n* @class Bodies\n*/\n\n// TODO: true circle bodies\n\nvar Bodies = {};\n\nmodule.exports = Bodies;\n\nvar Vertices = _dereq_('../geometry/Vertices');\nvar Common = _dereq_('../core/Common');\nvar Body = _dereq_('../body/Body');\nvar Bounds = _dereq_('../geometry/Bounds');\nvar Vector = _dereq_('../geometry/Vector');\nvar decomp = (typeof window !== \"undefined\" ? window['decomp'] : typeof global !== \"undefined\" ? global['decomp'] : null);\n\n(function() {\n\n    /**\n     * Creates a new rigid body model with a rectangle hull. \n     * The options parameter is an object that specifies any properties you wish to override the defaults.\n     * See the properties section of the `Matter.Body` module for detailed information on what you can pass via the `options` object.\n     * @method rectangle\n     * @param {number} x\n     * @param {number} y\n     * @param {number} width\n     * @param {number} height\n     * @param {object} [options]\n     * @return {body} A new rectangle body\n     */\n    Bodies.rectangle = function(x, y, width, height, options) {\n        options = options || {};\n\n        var rectangle = { \n            label: 'Rectangle Body',\n            position: { x: x, y: y },\n            vertices: Vertices.fromPath('L 0 0 L ' + width + ' 0 L ' + width + ' ' + height + ' L 0 ' + height)\n        };\n\n        if (options.chamfer) {\n            var chamfer = options.chamfer;\n            rectangle.vertices = Vertices.chamfer(rectangle.vertices, chamfer.radius, \n                                    chamfer.quality, chamfer.qualityMin, chamfer.qualityMax);\n            delete options.chamfer;\n        }\n\n        return Body.create(Common.extend({}, rectangle, options));\n    };\n    \n    /**\n     * Creates a new rigid body model with a trapezoid hull. \n     * The options parameter is an object that specifies any properties you wish to override the defaults.\n     * See the properties section of the `Matter.Body` module for detailed information on what you can pass via the `options` object.\n     * @method trapezoid\n     * @param {number} x\n     * @param {number} y\n     * @param {number} width\n     * @param {number} height\n     * @param {number} slope\n     * @param {object} [options]\n     * @return {body} A new trapezoid body\n     */\n    Bodies.trapezoid = function(x, y, width, height, slope, options) {\n        options = options || {};\n\n        slope *= 0.5;\n        var roof = (1 - (slope * 2)) * width;\n        \n        var x1 = width * slope,\n            x2 = x1 + roof,\n            x3 = x2 + x1,\n            verticesPath;\n\n        if (slope < 0.5) {\n            verticesPath = 'L 0 0 L ' + x1 + ' ' + (-height) + ' L ' + x2 + ' ' + (-height) + ' L ' + x3 + ' 0';\n        } else {\n            verticesPath = 'L 0 0 L ' + x2 + ' ' + (-height) + ' L ' + x3 + ' 0';\n        }\n\n        var trapezoid = { \n            label: 'Trapezoid Body',\n            position: { x: x, y: y },\n            vertices: Vertices.fromPath(verticesPath)\n        };\n\n        if (options.chamfer) {\n            var chamfer = options.chamfer;\n            trapezoid.vertices = Vertices.chamfer(trapezoid.vertices, chamfer.radius, \n                                    chamfer.quality, chamfer.qualityMin, chamfer.qualityMax);\n            delete options.chamfer;\n        }\n\n        return Body.create(Common.extend({}, trapezoid, options));\n    };\n\n    /**\n     * Creates a new rigid body model with a circle hull. \n     * The options parameter is an object that specifies any properties you wish to override the defaults.\n     * See the properties section of the `Matter.Body` module for detailed information on what you can pass via the `options` object.\n     * @method circle\n     * @param {number} x\n     * @param {number} y\n     * @param {number} radius\n     * @param {object} [options]\n     * @param {number} [maxSides]\n     * @return {body} A new circle body\n     */\n    Bodies.circle = function(x, y, radius, options, maxSides) {\n        options = options || {};\n\n        var circle = {\n            label: 'Circle Body',\n            circleRadius: radius\n        };\n        \n        // approximate circles with polygons until true circles implemented in SAT\n        maxSides = maxSides || 25;\n        var sides = Math.ceil(Math.max(10, Math.min(maxSides, radius)));\n\n        // optimisation: always use even number of sides (half the number of unique axes)\n        if (sides % 2 === 1)\n            sides += 1;\n\n        return Bodies.polygon(x, y, sides, radius, Common.extend({}, circle, options));\n    };\n\n    /**\n     * Creates a new rigid body model with a regular polygon hull with the given number of sides. \n     * The options parameter is an object that specifies any properties you wish to override the defaults.\n     * See the properties section of the `Matter.Body` module for detailed information on what you can pass via the `options` object.\n     * @method polygon\n     * @param {number} x\n     * @param {number} y\n     * @param {number} sides\n     * @param {number} radius\n     * @param {object} [options]\n     * @return {body} A new regular polygon body\n     */\n    Bodies.polygon = function(x, y, sides, radius, options) {\n        options = options || {};\n\n        if (sides < 3)\n            return Bodies.circle(x, y, radius, options);\n\n        var theta = 2 * Math.PI / sides,\n            path = '',\n            offset = theta * 0.5;\n\n        for (var i = 0; i < sides; i += 1) {\n            var angle = offset + (i * theta),\n                xx = Math.cos(angle) * radius,\n                yy = Math.sin(angle) * radius;\n\n            path += 'L ' + xx.toFixed(3) + ' ' + yy.toFixed(3) + ' ';\n        }\n\n        var polygon = { \n            label: 'Polygon Body',\n            position: { x: x, y: y },\n            vertices: Vertices.fromPath(path)\n        };\n\n        if (options.chamfer) {\n            var chamfer = options.chamfer;\n            polygon.vertices = Vertices.chamfer(polygon.vertices, chamfer.radius, \n                                    chamfer.quality, chamfer.qualityMin, chamfer.qualityMax);\n            delete options.chamfer;\n        }\n\n        return Body.create(Common.extend({}, polygon, options));\n    };\n\n    /**\n     * Creates a body using the supplied vertices (or an array containing multiple sets of vertices).\n     * If the vertices are convex, they will pass through as supplied.\n     * Otherwise if the vertices are concave, they will be decomposed if [poly-decomp.js](https://github.com/schteppe/poly-decomp.js) is available.\n     * Note that this process is not guaranteed to support complex sets of vertices (e.g. those with holes may fail).\n     * By default the decomposition will discard collinear edges (to improve performance).\n     * It can also optionally discard any parts that have an area less than `minimumArea`.\n     * If the vertices can not be decomposed, the result will fall back to using the convex hull.\n     * The options parameter is an object that specifies any `Matter.Body` properties you wish to override the defaults.\n     * See the properties section of the `Matter.Body` module for detailed information on what you can pass via the `options` object.\n     * @method fromVertices\n     * @param {number} x\n     * @param {number} y\n     * @param [[vector]] vertexSets\n     * @param {object} [options]\n     * @param {bool} [flagInternal=false]\n     * @param {number} [removeCollinear=0.01]\n     * @param {number} [minimumArea=10]\n     * @return {body}\n     */\n    Bodies.fromVertices = function(x, y, vertexSets, options, flagInternal, removeCollinear, minimumArea) {\n        var body,\n            parts,\n            isConvex,\n            vertices,\n            i,\n            j,\n            k,\n            v,\n            z;\n\n        options = options || {};\n        parts = [];\n\n        flagInternal = typeof flagInternal !== 'undefined' ? flagInternal : false;\n        removeCollinear = typeof removeCollinear !== 'undefined' ? removeCollinear : 0.01;\n        minimumArea = typeof minimumArea !== 'undefined' ? minimumArea : 10;\n\n        if (!decomp) {\n            Common.warn('Bodies.fromVertices: poly-decomp.js required. Could not decompose vertices. Fallback to convex hull.');\n        }\n\n        // ensure vertexSets is an array of arrays\n        if (!Common.isArray(vertexSets[0])) {\n            vertexSets = [vertexSets];\n        }\n\n        for (v = 0; v < vertexSets.length; v += 1) {\n            vertices = vertexSets[v];\n            isConvex = Vertices.isConvex(vertices);\n\n            if (isConvex || !decomp) {\n                if (isConvex) {\n                    vertices = Vertices.clockwiseSort(vertices);\n                } else {\n                    // fallback to convex hull when decomposition is not possible\n                    vertices = Vertices.hull(vertices);\n                }\n\n                parts.push({\n                    position: { x: x, y: y },\n                    vertices: vertices\n                });\n            } else {\n                // initialise a decomposition\n                var concave = vertices.map(function(vertex) {\n                    return [vertex.x, vertex.y];\n                });\n\n                // vertices are concave and simple, we can decompose into parts\n                decomp.makeCCW(concave);\n                if (removeCollinear !== false)\n                    decomp.removeCollinearPoints(concave, removeCollinear);\n\n                // use the quick decomposition algorithm (Bayazit)\n                var decomposed = decomp.quickDecomp(concave);\n\n                // for each decomposed chunk\n                for (i = 0; i < decomposed.length; i++) {\n                    var chunk = decomposed[i];\n\n                    // convert vertices into the correct structure\n                    var chunkVertices = chunk.map(function(vertices) {\n                        return {\n                            x: vertices[0],\n                            y: vertices[1]\n                        };\n                    });\n\n                    // skip small chunks\n                    if (minimumArea > 0 && Vertices.area(chunkVertices) < minimumArea)\n                        continue;\n\n                    // create a compound part\n                    parts.push({\n                        position: Vertices.centre(chunkVertices),\n                        vertices: chunkVertices\n                    });\n                }\n            }\n        }\n\n        // create body parts\n        for (i = 0; i < parts.length; i++) {\n            parts[i] = Body.create(Common.extend(parts[i], options));\n        }\n\n        // flag internal edges (coincident part edges)\n        if (flagInternal) {\n            var coincident_max_dist = 5;\n\n            for (i = 0; i < parts.length; i++) {\n                var partA = parts[i];\n\n                for (j = i + 1; j < parts.length; j++) {\n                    var partB = parts[j];\n\n                    if (Bounds.overlaps(partA.bounds, partB.bounds)) {\n                        var pav = partA.vertices,\n                            pbv = partB.vertices;\n\n                        // iterate vertices of both parts\n                        for (k = 0; k < partA.vertices.length; k++) {\n                            for (z = 0; z < partB.vertices.length; z++) {\n                                // find distances between the vertices\n                                var da = Vector.magnitudeSquared(Vector.sub(pav[(k + 1) % pav.length], pbv[z])),\n                                    db = Vector.magnitudeSquared(Vector.sub(pav[k], pbv[(z + 1) % pbv.length]));\n\n                                // if both vertices are very close, consider the edge concident (internal)\n                                if (da < coincident_max_dist && db < coincident_max_dist) {\n                                    pav[k].isInternal = true;\n                                    pbv[z].isInternal = true;\n                                }\n                            }\n                        }\n\n                    }\n                }\n            }\n        }\n\n        if (parts.length > 1) {\n            // create the parent body to be returned, that contains generated compound parts\n            body = Body.create(Common.extend({ parts: parts.slice(0) }, options));\n            Body.setPosition(body, { x: x, y: y });\n\n            return body;\n        } else {\n            return parts[0];\n        }\n    };\n\n})();\n\n}).call(this,typeof global !== \"undefined\" ? global : typeof self !== \"undefined\" ? self : typeof window !== \"undefined\" ? window : {})\n},{\"../body/Body\":1,\"../core/Common\":14,\"../geometry/Bounds\":26,\"../geometry/Vector\":28,\"../geometry/Vertices\":29}],24:[function(_dereq_,module,exports){\n/**\n* The `Matter.Composites` module contains factory methods for creating composite bodies\n* with commonly used configurations (such as stacks and chains).\n*\n* See the included usage [examples](https://github.com/liabru/matter-js/tree/master/examples).\n*\n* @class Composites\n*/\n\nvar Composites = {};\n\nmodule.exports = Composites;\n\nvar Composite = _dereq_('../body/Composite');\nvar Constraint = _dereq_('../constraint/Constraint');\nvar Common = _dereq_('../core/Common');\nvar Body = _dereq_('../body/Body');\nvar Bodies = _dereq_('./Bodies');\n\n(function() {\n\n    /**\n     * Create a new composite containing bodies created in the callback in a grid arrangement.\n     * This function uses the body's bounds to prevent overlaps.\n     * @method stack\n     * @param {number} xx\n     * @param {number} yy\n     * @param {number} columns\n     * @param {number} rows\n     * @param {number} columnGap\n     * @param {number} rowGap\n     * @param {function} callback\n     * @return {composite} A new composite containing objects created in the callback\n     */\n    Composites.stack = function(xx, yy, columns, rows, columnGap, rowGap, callback) {\n        var stack = Composite.create({ label: 'Stack' }),\n            x = xx,\n            y = yy,\n            lastBody,\n            i = 0;\n\n        for (var row = 0; row < rows; row++) {\n            var maxHeight = 0;\n            \n            for (var column = 0; column < columns; column++) {\n                var body = callback(x, y, column, row, lastBody, i);\n                    \n                if (body) {\n                    var bodyHeight = body.bounds.max.y - body.bounds.min.y,\n                        bodyWidth = body.bounds.max.x - body.bounds.min.x; \n\n                    if (bodyHeight > maxHeight)\n                        maxHeight = bodyHeight;\n                    \n                    Body.translate(body, { x: bodyWidth * 0.5, y: bodyHeight * 0.5 });\n\n                    x = body.bounds.max.x + columnGap;\n\n                    Composite.addBody(stack, body);\n                    \n                    lastBody = body;\n                    i += 1;\n                } else {\n                    x += columnGap;\n                }\n            }\n            \n            y += maxHeight + rowGap;\n            x = xx;\n        }\n\n        return stack;\n    };\n    \n    /**\n     * Chains all bodies in the given composite together using constraints.\n     * @method chain\n     * @param {composite} composite\n     * @param {number} xOffsetA\n     * @param {number} yOffsetA\n     * @param {number} xOffsetB\n     * @param {number} yOffsetB\n     * @param {object} options\n     * @return {composite} A new composite containing objects chained together with constraints\n     */\n    Composites.chain = function(composite, xOffsetA, yOffsetA, xOffsetB, yOffsetB, options) {\n        var bodies = composite.bodies;\n        \n        for (var i = 1; i < bodies.length; i++) {\n            var bodyA = bodies[i - 1],\n                bodyB = bodies[i],\n                bodyAHeight = bodyA.bounds.max.y - bodyA.bounds.min.y,\n                bodyAWidth = bodyA.bounds.max.x - bodyA.bounds.min.x, \n                bodyBHeight = bodyB.bounds.max.y - bodyB.bounds.min.y,\n                bodyBWidth = bodyB.bounds.max.x - bodyB.bounds.min.x;\n        \n            var defaults = {\n                bodyA: bodyA,\n                pointA: { x: bodyAWidth * xOffsetA, y: bodyAHeight * yOffsetA },\n                bodyB: bodyB,\n                pointB: { x: bodyBWidth * xOffsetB, y: bodyBHeight * yOffsetB }\n            };\n            \n            var constraint = Common.extend(defaults, options);\n        \n            Composite.addConstraint(composite, Constraint.create(constraint));\n        }\n\n        composite.label += ' Chain';\n        \n        return composite;\n    };\n\n    /**\n     * Connects bodies in the composite with constraints in a grid pattern, with optional cross braces.\n     * @method mesh\n     * @param {composite} composite\n     * @param {number} columns\n     * @param {number} rows\n     * @param {boolean} crossBrace\n     * @param {object} options\n     * @return {composite} The composite containing objects meshed together with constraints\n     */\n    Composites.mesh = function(composite, columns, rows, crossBrace, options) {\n        var bodies = composite.bodies,\n            row,\n            col,\n            bodyA,\n            bodyB,\n            bodyC;\n        \n        for (row = 0; row < rows; row++) {\n            for (col = 1; col < columns; col++) {\n                bodyA = bodies[(col - 1) + (row * columns)];\n                bodyB = bodies[col + (row * columns)];\n                Composite.addConstraint(composite, Constraint.create(Common.extend({ bodyA: bodyA, bodyB: bodyB }, options)));\n            }\n\n            if (row > 0) {\n                for (col = 0; col < columns; col++) {\n                    bodyA = bodies[col + ((row - 1) * columns)];\n                    bodyB = bodies[col + (row * columns)];\n                    Composite.addConstraint(composite, Constraint.create(Common.extend({ bodyA: bodyA, bodyB: bodyB }, options)));\n\n                    if (crossBrace && col > 0) {\n                        bodyC = bodies[(col - 1) + ((row - 1) * columns)];\n                        Composite.addConstraint(composite, Constraint.create(Common.extend({ bodyA: bodyC, bodyB: bodyB }, options)));\n                    }\n\n                    if (crossBrace && col < columns - 1) {\n                        bodyC = bodies[(col + 1) + ((row - 1) * columns)];\n                        Composite.addConstraint(composite, Constraint.create(Common.extend({ bodyA: bodyC, bodyB: bodyB }, options)));\n                    }\n                }\n            }\n        }\n\n        composite.label += ' Mesh';\n        \n        return composite;\n    };\n    \n    /**\n     * Create a new composite containing bodies created in the callback in a pyramid arrangement.\n     * This function uses the body's bounds to prevent overlaps.\n     * @method pyramid\n     * @param {number} xx\n     * @param {number} yy\n     * @param {number} columns\n     * @param {number} rows\n     * @param {number} columnGap\n     * @param {number} rowGap\n     * @param {function} callback\n     * @return {composite} A new composite containing objects created in the callback\n     */\n    Composites.pyramid = function(xx, yy, columns, rows, columnGap, rowGap, callback) {\n        return Composites.stack(xx, yy, columns, rows, columnGap, rowGap, function(x, y, column, row, lastBody, i) {\n            var actualRows = Math.min(rows, Math.ceil(columns / 2)),\n                lastBodyWidth = lastBody ? lastBody.bounds.max.x - lastBody.bounds.min.x : 0;\n            \n            if (row > actualRows)\n                return;\n            \n            // reverse row order\n            row = actualRows - row;\n            \n            var start = row,\n                end = columns - 1 - row;\n\n            if (column < start || column > end)\n                return;\n            \n            // retroactively fix the first body's position, since width was unknown\n            if (i === 1) {\n                Body.translate(lastBody, { x: (column + (columns % 2 === 1 ? 1 : -1)) * lastBodyWidth, y: 0 });\n            }\n\n            var xOffset = lastBody ? column * lastBodyWidth : 0;\n            \n            return callback(xx + xOffset + column * columnGap, y, column, row, lastBody, i);\n        });\n    };\n\n    /**\n     * Creates a composite with a Newton's Cradle setup of bodies and constraints.\n     * @method newtonsCradle\n     * @param {number} xx\n     * @param {number} yy\n     * @param {number} number\n     * @param {number} size\n     * @param {number} length\n     * @return {composite} A new composite newtonsCradle body\n     */\n    Composites.newtonsCradle = function(xx, yy, number, size, length) {\n        var newtonsCradle = Composite.create({ label: 'Newtons Cradle' });\n\n        for (var i = 0; i < number; i++) {\n            var separation = 1.9,\n                circle = Bodies.circle(xx + i * (size * separation), yy + length, size, \n                            { inertia: Infinity, restitution: 1, friction: 0, frictionAir: 0.0001, slop: 1 }),\n                constraint = Constraint.create({ pointA: { x: xx + i * (size * separation), y: yy }, bodyB: circle });\n\n            Composite.addBody(newtonsCradle, circle);\n            Composite.addConstraint(newtonsCradle, constraint);\n        }\n\n        return newtonsCradle;\n    };\n    \n    /**\n     * Creates a composite with simple car setup of bodies and constraints.\n     * @method car\n     * @param {number} xx\n     * @param {number} yy\n     * @param {number} width\n     * @param {number} height\n     * @param {number} wheelSize\n     * @return {composite} A new composite car body\n     */\n    Composites.car = function(xx, yy, width, height, wheelSize) {\n        var group = Body.nextGroup(true),\n            wheelBase = 20,\n            wheelAOffset = -width * 0.5 + wheelBase,\n            wheelBOffset = width * 0.5 - wheelBase,\n            wheelYOffset = 0;\n    \n        var car = Composite.create({ label: 'Car' }),\n            body = Bodies.rectangle(xx, yy, width, height, { \n                collisionFilter: {\n                    group: group\n                },\n                chamfer: {\n                    radius: height * 0.5\n                },\n                density: 0.0002\n            });\n    \n        var wheelA = Bodies.circle(xx + wheelAOffset, yy + wheelYOffset, wheelSize, { \n            collisionFilter: {\n                group: group\n            },\n            friction: 0.8\n        });\n                    \n        var wheelB = Bodies.circle(xx + wheelBOffset, yy + wheelYOffset, wheelSize, { \n            collisionFilter: {\n                group: group\n            },\n            friction: 0.8\n        });\n                    \n        var axelA = Constraint.create({\n            bodyB: body,\n            pointB: { x: wheelAOffset, y: wheelYOffset },\n            bodyA: wheelA,\n            stiffness: 1,\n            length: 0\n        });\n                        \n        var axelB = Constraint.create({\n            bodyB: body,\n            pointB: { x: wheelBOffset, y: wheelYOffset },\n            bodyA: wheelB,\n            stiffness: 1,\n            length: 0\n        });\n        \n        Composite.addBody(car, body);\n        Composite.addBody(car, wheelA);\n        Composite.addBody(car, wheelB);\n        Composite.addConstraint(car, axelA);\n        Composite.addConstraint(car, axelB);\n\n        return car;\n    };\n\n    /**\n     * Creates a simple soft body like object.\n     * @method softBody\n     * @param {number} xx\n     * @param {number} yy\n     * @param {number} columns\n     * @param {number} rows\n     * @param {number} columnGap\n     * @param {number} rowGap\n     * @param {boolean} crossBrace\n     * @param {number} particleRadius\n     * @param {} particleOptions\n     * @param {} constraintOptions\n     * @return {composite} A new composite softBody\n     */\n    Composites.softBody = function(xx, yy, columns, rows, columnGap, rowGap, crossBrace, particleRadius, particleOptions, constraintOptions) {\n        particleOptions = Common.extend({ inertia: Infinity }, particleOptions);\n        constraintOptions = Common.extend({ stiffness: 0.2, render: { type: 'line', anchors: false } }, constraintOptions);\n\n        var softBody = Composites.stack(xx, yy, columns, rows, columnGap, rowGap, function(x, y) {\n            return Bodies.circle(x, y, particleRadius, particleOptions);\n        });\n\n        Composites.mesh(softBody, columns, rows, crossBrace, constraintOptions);\n\n        softBody.label = 'Soft Body';\n\n        return softBody;\n    };\n\n})();\n\n},{\"../body/Body\":1,\"../body/Composite\":2,\"../constraint/Constraint\":12,\"../core/Common\":14,\"./Bodies\":23}],25:[function(_dereq_,module,exports){\n/**\n* The `Matter.Axes` module contains methods for creating and manipulating sets of axes.\n*\n* @class Axes\n*/\n\nvar Axes = {};\n\nmodule.exports = Axes;\n\nvar Vector = _dereq_('../geometry/Vector');\nvar Common = _dereq_('../core/Common');\n\n(function() {\n\n    /**\n     * Creates a new set of axes from the given vertices.\n     * @method fromVertices\n     * @param {vertices} vertices\n     * @return {axes} A new axes from the given vertices\n     */\n    Axes.fromVertices = function(vertices) {\n        var axes = {};\n\n        // find the unique axes, using edge normal gradients\n        for (var i = 0; i < vertices.length; i++) {\n            var j = (i + 1) % vertices.length, \n                normal = Vector.normalise({ \n                    x: vertices[j].y - vertices[i].y, \n                    y: vertices[i].x - vertices[j].x\n                }),\n                gradient = (normal.y === 0) ? Infinity : (normal.x / normal.y);\n            \n            // limit precision\n            gradient = gradient.toFixed(3).toString();\n            axes[gradient] = normal;\n        }\n\n        return Common.values(axes);\n    };\n\n    /**\n     * Rotates a set of axes by the given angle.\n     * @method rotate\n     * @param {axes} axes\n     * @param {number} angle\n     */\n    Axes.rotate = function(axes, angle) {\n        if (angle === 0)\n            return;\n        \n        var cos = Math.cos(angle),\n            sin = Math.sin(angle);\n\n        for (var i = 0; i < axes.length; i++) {\n            var axis = axes[i],\n                xx;\n            xx = axis.x * cos - axis.y * sin;\n            axis.y = axis.x * sin + axis.y * cos;\n            axis.x = xx;\n        }\n    };\n\n})();\n\n},{\"../core/Common\":14,\"../geometry/Vector\":28}],26:[function(_dereq_,module,exports){\n/**\n* The `Matter.Bounds` module contains methods for creating and manipulating axis-aligned bounding boxes (AABB).\n*\n* @class Bounds\n*/\n\nvar Bounds = {};\n\nmodule.exports = Bounds;\n\n(function() {\n\n    /**\n     * Creates a new axis-aligned bounding box (AABB) for the given vertices.\n     * @method create\n     * @param {vertices} vertices\n     * @return {bounds} A new bounds object\n     */\n    Bounds.create = function(vertices) {\n        var bounds = { \n            min: { x: 0, y: 0 }, \n            max: { x: 0, y: 0 }\n        };\n\n        if (vertices)\n            Bounds.update(bounds, vertices);\n        \n        return bounds;\n    };\n\n    /**\n     * Updates bounds using the given vertices and extends the bounds given a velocity.\n     * @method update\n     * @param {bounds} bounds\n     * @param {vertices} vertices\n     * @param {vector} velocity\n     */\n    Bounds.update = function(bounds, vertices, velocity) {\n        bounds.min.x = Infinity;\n        bounds.max.x = -Infinity;\n        bounds.min.y = Infinity;\n        bounds.max.y = -Infinity;\n\n        for (var i = 0; i < vertices.length; i++) {\n            var vertex = vertices[i];\n            if (vertex.x > bounds.max.x) bounds.max.x = vertex.x;\n            if (vertex.x < bounds.min.x) bounds.min.x = vertex.x;\n            if (vertex.y > bounds.max.y) bounds.max.y = vertex.y;\n            if (vertex.y < bounds.min.y) bounds.min.y = vertex.y;\n        }\n        \n        if (velocity) {\n            if (velocity.x > 0) {\n                bounds.max.x += velocity.x;\n            } else {\n                bounds.min.x += velocity.x;\n            }\n            \n            if (velocity.y > 0) {\n                bounds.max.y += velocity.y;\n            } else {\n                bounds.min.y += velocity.y;\n            }\n        }\n    };\n\n    /**\n     * Returns true if the bounds contains the given point.\n     * @method contains\n     * @param {bounds} bounds\n     * @param {vector} point\n     * @return {boolean} True if the bounds contain the point, otherwise false\n     */\n    Bounds.contains = function(bounds, point) {\n        return point.x >= bounds.min.x && point.x <= bounds.max.x \n               && point.y >= bounds.min.y && point.y <= bounds.max.y;\n    };\n\n    /**\n     * Returns true if the two bounds intersect.\n     * @method overlaps\n     * @param {bounds} boundsA\n     * @param {bounds} boundsB\n     * @return {boolean} True if the bounds overlap, otherwise false\n     */\n    Bounds.overlaps = function(boundsA, boundsB) {\n        return (boundsA.min.x <= boundsB.max.x && boundsA.max.x >= boundsB.min.x\n                && boundsA.max.y >= boundsB.min.y && boundsA.min.y <= boundsB.max.y);\n    };\n\n    /**\n     * Translates the bounds by the given vector.\n     * @method translate\n     * @param {bounds} bounds\n     * @param {vector} vector\n     */\n    Bounds.translate = function(bounds, vector) {\n        bounds.min.x += vector.x;\n        bounds.max.x += vector.x;\n        bounds.min.y += vector.y;\n        bounds.max.y += vector.y;\n    };\n\n    /**\n     * Shifts the bounds to the given position.\n     * @method shift\n     * @param {bounds} bounds\n     * @param {vector} position\n     */\n    Bounds.shift = function(bounds, position) {\n        var deltaX = bounds.max.x - bounds.min.x,\n            deltaY = bounds.max.y - bounds.min.y;\n            \n        bounds.min.x = position.x;\n        bounds.max.x = position.x + deltaX;\n        bounds.min.y = position.y;\n        bounds.max.y = position.y + deltaY;\n    };\n    \n})();\n\n},{}],27:[function(_dereq_,module,exports){\n/**\n* The `Matter.Svg` module contains methods for converting SVG images into an array of vector points.\n*\n* To use this module you also need the SVGPathSeg polyfill: https://github.com/progers/pathseg\n*\n* See the included usage [examples](https://github.com/liabru/matter-js/tree/master/examples).\n*\n* @class Svg\n*/\n\nvar Svg = {};\n\nmodule.exports = Svg;\n\nvar Bounds = _dereq_('../geometry/Bounds');\n\n(function() {\n\n    /**\n     * Converts an SVG path into an array of vector points.\n     * If the input path forms a concave shape, you must decompose the result into convex parts before use.\n     * See `Bodies.fromVertices` which provides support for this.\n     * Note that this function is not guaranteed to support complex paths (such as those with holes).\n     * @method pathToVertices\n     * @param {SVGPathElement} path\n     * @param {Number} [sampleLength=15]\n     * @return {Vector[]} points\n     */\n    Svg.pathToVertices = function(path, sampleLength) {\n        // https://github.com/wout/svg.topoly.js/blob/master/svg.topoly.js\n        var i, il, total, point, segment, segments, \n            segmentsQueue, lastSegment, \n            lastPoint, segmentIndex, points = [],\n            lx, ly, length = 0, x = 0, y = 0;\n\n        sampleLength = sampleLength || 15;\n\n        var addPoint = function(px, py, pathSegType) {\n            // all odd-numbered path types are relative except PATHSEG_CLOSEPATH (1)\n            var isRelative = pathSegType % 2 === 1 && pathSegType > 1;\n\n            // when the last point doesn't equal the current point add the current point\n            if (!lastPoint || px != lastPoint.x || py != lastPoint.y) {\n                if (lastPoint && isRelative) {\n                    lx = lastPoint.x;\n                    ly = lastPoint.y;\n                } else {\n                    lx = 0;\n                    ly = 0;\n                }\n\n                var point = {\n                    x: lx + px,\n                    y: ly + py\n                };\n\n                // set last point\n                if (isRelative || !lastPoint) {\n                    lastPoint = point;\n                }\n\n                points.push(point);\n\n                x = lx + px;\n                y = ly + py;\n            }\n        };\n\n        var addSegmentPoint = function(segment) {\n            var segType = segment.pathSegTypeAsLetter.toUpperCase();\n\n            // skip path ends\n            if (segType === 'Z') \n                return;\n\n            // map segment to x and y\n            switch (segType) {\n\n            case 'M':\n            case 'L':\n            case 'T':\n            case 'C':\n            case 'S':\n            case 'Q':\n                x = segment.x;\n                y = segment.y;\n                break;\n            case 'H':\n                x = segment.x;\n                break;\n            case 'V':\n                y = segment.y;\n                break;\n            }\n\n            addPoint(x, y, segment.pathSegType);\n        };\n\n        // ensure path is absolute\n        Svg._svgPathToAbsolute(path);\n\n        // get total length\n        total = path.getTotalLength();\n\n        // queue segments\n        segments = [];\n        for (i = 0; i < path.pathSegList.numberOfItems; i += 1)\n            segments.push(path.pathSegList.getItem(i));\n\n        segmentsQueue = segments.concat();\n\n        // sample through path\n        while (length < total) {\n            // get segment at position\n            segmentIndex = path.getPathSegAtLength(length);\n            segment = segments[segmentIndex];\n\n            // new segment\n            if (segment != lastSegment) {\n                while (segmentsQueue.length && segmentsQueue[0] != segment)\n                    addSegmentPoint(segmentsQueue.shift());\n\n                lastSegment = segment;\n            }\n\n            // add points in between when curving\n            // TODO: adaptive sampling\n            switch (segment.pathSegTypeAsLetter.toUpperCase()) {\n\n            case 'C':\n            case 'T':\n            case 'S':\n            case 'Q':\n            case 'A':\n                point = path.getPointAtLength(length);\n                addPoint(point.x, point.y, 0);\n                break;\n\n            }\n\n            // increment by sample value\n            length += sampleLength;\n        }\n\n        // add remaining segments not passed by sampling\n        for (i = 0, il = segmentsQueue.length; i < il; ++i)\n            addSegmentPoint(segmentsQueue[i]);\n\n        return points;\n    };\n\n    Svg._svgPathToAbsolute = function(path) {\n        // http://phrogz.net/convert-svg-path-to-all-absolute-commands\n        // Copyright (c) Gavin Kistner\n        // http://phrogz.net/js/_ReuseLicense.txt\n        // Modifications: tidy formatting and naming\n        var x0, y0, x1, y1, x2, y2, segs = path.pathSegList,\n            x = 0, y = 0, len = segs.numberOfItems;\n\n        for (var i = 0; i < len; ++i) {\n            var seg = segs.getItem(i),\n                segType = seg.pathSegTypeAsLetter;\n\n            if (/[MLHVCSQTA]/.test(segType)) {\n                if ('x' in seg) x = seg.x;\n                if ('y' in seg) y = seg.y;\n            } else {\n                if ('x1' in seg) x1 = x + seg.x1;\n                if ('x2' in seg) x2 = x + seg.x2;\n                if ('y1' in seg) y1 = y + seg.y1;\n                if ('y2' in seg) y2 = y + seg.y2;\n                if ('x' in seg) x += seg.x;\n                if ('y' in seg) y += seg.y;\n\n                switch (segType) {\n\n                case 'm':\n                    segs.replaceItem(path.createSVGPathSegMovetoAbs(x, y), i);\n                    break;\n                case 'l':\n                    segs.replaceItem(path.createSVGPathSegLinetoAbs(x, y), i);\n                    break;\n                case 'h':\n                    segs.replaceItem(path.createSVGPathSegLinetoHorizontalAbs(x), i);\n                    break;\n                case 'v':\n                    segs.replaceItem(path.createSVGPathSegLinetoVerticalAbs(y), i);\n                    break;\n                case 'c':\n                    segs.replaceItem(path.createSVGPathSegCurvetoCubicAbs(x, y, x1, y1, x2, y2), i);\n                    break;\n                case 's':\n                    segs.replaceItem(path.createSVGPathSegCurvetoCubicSmoothAbs(x, y, x2, y2), i);\n                    break;\n                case 'q':\n                    segs.replaceItem(path.createSVGPathSegCurvetoQuadraticAbs(x, y, x1, y1), i);\n                    break;\n                case 't':\n                    segs.replaceItem(path.createSVGPathSegCurvetoQuadraticSmoothAbs(x, y), i);\n                    break;\n                case 'a':\n                    segs.replaceItem(path.createSVGPathSegArcAbs(x, y, seg.r1, seg.r2, seg.angle, seg.largeArcFlag, seg.sweepFlag), i);\n                    break;\n                case 'z':\n                case 'Z':\n                    x = x0;\n                    y = y0;\n                    break;\n\n                }\n            }\n\n            if (segType == 'M' || segType == 'm') {\n                x0 = x;\n                y0 = y;\n            }\n        }\n    };\n\n})();\n},{\"../geometry/Bounds\":26}],28:[function(_dereq_,module,exports){\n/**\n* The `Matter.Vector` module contains methods for creating and manipulating vectors.\n* Vectors are the basis of all the geometry related operations in the engine.\n* A `Matter.Vector` object is of the form `{ x: 0, y: 0 }`.\n*\n* See the included usage [examples](https://github.com/liabru/matter-js/tree/master/examples).\n*\n* @class Vector\n*/\n\n// TODO: consider params for reusing vector objects\n\nvar Vector = {};\n\nmodule.exports = Vector;\n\n(function() {\n\n    /**\n     * Creates a new vector.\n     * @method create\n     * @param {number} x\n     * @param {number} y\n     * @return {vector} A new vector\n     */\n    Vector.create = function(x, y) {\n        return { x: x || 0, y: y || 0 };\n    };\n\n    /**\n     * Returns a new vector with `x` and `y` copied from the given `vector`.\n     * @method clone\n     * @param {vector} vector\n     * @return {vector} A new cloned vector\n     */\n    Vector.clone = function(vector) {\n        return { x: vector.x, y: vector.y };\n    };\n\n    /**\n     * Returns the magnitude (length) of a vector.\n     * @method magnitude\n     * @param {vector} vector\n     * @return {number} The magnitude of the vector\n     */\n    Vector.magnitude = function(vector) {\n        return Math.sqrt((vector.x * vector.x) + (vector.y * vector.y));\n    };\n\n    /**\n     * Returns the magnitude (length) of a vector (therefore saving a `sqrt` operation).\n     * @method magnitudeSquared\n     * @param {vector} vector\n     * @return {number} The squared magnitude of the vector\n     */\n    Vector.magnitudeSquared = function(vector) {\n        return (vector.x * vector.x) + (vector.y * vector.y);\n    };\n\n    /**\n     * Rotates the vector about (0, 0) by specified angle.\n     * @method rotate\n     * @param {vector} vector\n     * @param {number} angle\n     * @param {vector} [output]\n     * @return {vector} The vector rotated about (0, 0)\n     */\n    Vector.rotate = function(vector, angle, output) {\n        var cos = Math.cos(angle), sin = Math.sin(angle);\n        if (!output) output = {};\n        var x = vector.x * cos - vector.y * sin;\n        output.y = vector.x * sin + vector.y * cos;\n        output.x = x;\n        return output;\n    };\n\n    /**\n     * Rotates the vector about a specified point by specified angle.\n     * @method rotateAbout\n     * @param {vector} vector\n     * @param {number} angle\n     * @param {vector} point\n     * @param {vector} [output]\n     * @return {vector} A new vector rotated about the point\n     */\n    Vector.rotateAbout = function(vector, angle, point, output) {\n        var cos = Math.cos(angle), sin = Math.sin(angle);\n        if (!output) output = {};\n        var x = point.x + ((vector.x - point.x) * cos - (vector.y - point.y) * sin);\n        output.y = point.y + ((vector.x - point.x) * sin + (vector.y - point.y) * cos);\n        output.x = x;\n        return output;\n    };\n\n    /**\n     * Normalises a vector (such that its magnitude is `1`).\n     * @method normalise\n     * @param {vector} vector\n     * @return {vector} A new vector normalised\n     */\n    Vector.normalise = function(vector) {\n        var magnitude = Vector.magnitude(vector);\n        if (magnitude === 0)\n            return { x: 0, y: 0 };\n        return { x: vector.x / magnitude, y: vector.y / magnitude };\n    };\n\n    /**\n     * Returns the dot-product of two vectors.\n     * @method dot\n     * @param {vector} vectorA\n     * @param {vector} vectorB\n     * @return {number} The dot product of the two vectors\n     */\n    Vector.dot = function(vectorA, vectorB) {\n        return (vectorA.x * vectorB.x) + (vectorA.y * vectorB.y);\n    };\n\n    /**\n     * Returns the cross-product of two vectors.\n     * @method cross\n     * @param {vector} vectorA\n     * @param {vector} vectorB\n     * @return {number} The cross product of the two vectors\n     */\n    Vector.cross = function(vectorA, vectorB) {\n        return (vectorA.x * vectorB.y) - (vectorA.y * vectorB.x);\n    };\n\n    /**\n     * Returns the cross-product of three vectors.\n     * @method cross3\n     * @param {vector} vectorA\n     * @param {vector} vectorB\n     * @param {vector} vectorC\n     * @return {number} The cross product of the three vectors\n     */\n    Vector.cross3 = function(vectorA, vectorB, vectorC) {\n        return (vectorB.x - vectorA.x) * (vectorC.y - vectorA.y) - (vectorB.y - vectorA.y) * (vectorC.x - vectorA.x);\n    };\n\n    /**\n     * Adds the two vectors.\n     * @method add\n     * @param {vector} vectorA\n     * @param {vector} vectorB\n     * @param {vector} [output]\n     * @return {vector} A new vector of vectorA and vectorB added\n     */\n    Vector.add = function(vectorA, vectorB, output) {\n        if (!output) output = {};\n        output.x = vectorA.x + vectorB.x;\n        output.y = vectorA.y + vectorB.y;\n        return output;\n    };\n\n    /**\n     * Subtracts the two vectors.\n     * @method sub\n     * @param {vector} vectorA\n     * @param {vector} vectorB\n     * @param {vector} [output]\n     * @return {vector} A new vector of vectorA and vectorB subtracted\n     */\n    Vector.sub = function(vectorA, vectorB, output) {\n        if (!output) output = {};\n        output.x = vectorA.x - vectorB.x;\n        output.y = vectorA.y - vectorB.y;\n        return output;\n    };\n\n    /**\n     * Multiplies a vector and a scalar.\n     * @method mult\n     * @param {vector} vector\n     * @param {number} scalar\n     * @return {vector} A new vector multiplied by scalar\n     */\n    Vector.mult = function(vector, scalar) {\n        return { x: vector.x * scalar, y: vector.y * scalar };\n    };\n\n    /**\n     * Divides a vector and a scalar.\n     * @method div\n     * @param {vector} vector\n     * @param {number} scalar\n     * @return {vector} A new vector divided by scalar\n     */\n    Vector.div = function(vector, scalar) {\n        return { x: vector.x / scalar, y: vector.y / scalar };\n    };\n\n    /**\n     * Returns the perpendicular vector. Set `negate` to true for the perpendicular in the opposite direction.\n     * @method perp\n     * @param {vector} vector\n     * @param {bool} [negate=false]\n     * @return {vector} The perpendicular vector\n     */\n    Vector.perp = function(vector, negate) {\n        negate = negate === true ? -1 : 1;\n        return { x: negate * -vector.y, y: negate * vector.x };\n    };\n\n    /**\n     * Negates both components of a vector such that it points in the opposite direction.\n     * @method neg\n     * @param {vector} vector\n     * @return {vector} The negated vector\n     */\n    Vector.neg = function(vector) {\n        return { x: -vector.x, y: -vector.y };\n    };\n\n    /**\n     * Returns the angle in radians between the two vectors relative to the x-axis.\n     * @method angle\n     * @param {vector} vectorA\n     * @param {vector} vectorB\n     * @return {number} The angle in radians\n     */\n    Vector.angle = function(vectorA, vectorB) {\n        return Math.atan2(vectorB.y - vectorA.y, vectorB.x - vectorA.x);\n    };\n\n    /**\n     * Temporary vector pool (not thread-safe).\n     * @property _temp\n     * @type {vector[]}\n     * @private\n     */\n    Vector._temp = [\n        Vector.create(), Vector.create(), \n        Vector.create(), Vector.create(), \n        Vector.create(), Vector.create()\n    ];\n\n})();\n},{}],29:[function(_dereq_,module,exports){\n/**\n* The `Matter.Vertices` module contains methods for creating and manipulating sets of vertices.\n* A set of vertices is an array of `Matter.Vector` with additional indexing properties inserted by `Vertices.create`.\n* A `Matter.Body` maintains a set of vertices to represent the shape of the object (its convex hull).\n*\n* See the included usage [examples](https://github.com/liabru/matter-js/tree/master/examples).\n*\n* @class Vertices\n*/\n\nvar Vertices = {};\n\nmodule.exports = Vertices;\n\nvar Vector = _dereq_('../geometry/Vector');\nvar Common = _dereq_('../core/Common');\n\n(function() {\n\n    /**\n     * Creates a new set of `Matter.Body` compatible vertices.\n     * The `points` argument accepts an array of `Matter.Vector` points orientated around the origin `(0, 0)`, for example:\n     *\n     *     [{ x: 0, y: 0 }, { x: 25, y: 50 }, { x: 50, y: 0 }]\n     *\n     * The `Vertices.create` method returns a new array of vertices, which are similar to Matter.Vector objects,\n     * but with some additional references required for efficient collision detection routines.\n     *\n     * Vertices must be specified in clockwise order.\n     *\n     * Note that the `body` argument is not optional, a `Matter.Body` reference must be provided.\n     *\n     * @method create\n     * @param {vector[]} points\n     * @param {body} body\n     */\n    Vertices.create = function(points, body) {\n        var vertices = [];\n\n        for (var i = 0; i < points.length; i++) {\n            var point = points[i],\n                vertex = {\n                    x: point.x,\n                    y: point.y,\n                    index: i,\n                    body: body,\n                    isInternal: false\n                };\n\n            vertices.push(vertex);\n        }\n\n        return vertices;\n    };\n\n    /**\n     * Parses a string containing ordered x y pairs separated by spaces (and optionally commas), \n     * into a `Matter.Vertices` object for the given `Matter.Body`.\n     * For parsing SVG paths, see `Svg.pathToVertices`.\n     * @method fromPath\n     * @param {string} path\n     * @param {body} body\n     * @return {vertices} vertices\n     */\n    Vertices.fromPath = function(path, body) {\n        var pathPattern = /L?\\s*([\\-\\d\\.e]+)[\\s,]*([\\-\\d\\.e]+)*/ig,\n            points = [];\n\n        path.replace(pathPattern, function(match, x, y) {\n            points.push({ x: parseFloat(x), y: parseFloat(y) });\n        });\n\n        return Vertices.create(points, body);\n    };\n\n    /**\n     * Returns the centre (centroid) of the set of vertices.\n     * @method centre\n     * @param {vertices} vertices\n     * @return {vector} The centre point\n     */\n    Vertices.centre = function(vertices) {\n        var area = Vertices.area(vertices, true),\n            centre = { x: 0, y: 0 },\n            cross,\n            temp,\n            j;\n\n        for (var i = 0; i < vertices.length; i++) {\n            j = (i + 1) % vertices.length;\n            cross = Vector.cross(vertices[i], vertices[j]);\n            temp = Vector.mult(Vector.add(vertices[i], vertices[j]), cross);\n            centre = Vector.add(centre, temp);\n        }\n\n        return Vector.div(centre, 6 * area);\n    };\n\n    /**\n     * Returns the average (mean) of the set of vertices.\n     * @method mean\n     * @param {vertices} vertices\n     * @return {vector} The average point\n     */\n    Vertices.mean = function(vertices) {\n        var average = { x: 0, y: 0 };\n\n        for (var i = 0; i < vertices.length; i++) {\n            average.x += vertices[i].x;\n            average.y += vertices[i].y;\n        }\n\n        return Vector.div(average, vertices.length);\n    };\n\n    /**\n     * Returns the area of the set of vertices.\n     * @method area\n     * @param {vertices} vertices\n     * @param {bool} signed\n     * @return {number} The area\n     */\n    Vertices.area = function(vertices, signed) {\n        var area = 0,\n            j = vertices.length - 1;\n\n        for (var i = 0; i < vertices.length; i++) {\n            area += (vertices[j].x - vertices[i].x) * (vertices[j].y + vertices[i].y);\n            j = i;\n        }\n\n        if (signed)\n            return area / 2;\n\n        return Math.abs(area) / 2;\n    };\n\n    /**\n     * Returns the moment of inertia (second moment of area) of the set of vertices given the total mass.\n     * @method inertia\n     * @param {vertices} vertices\n     * @param {number} mass\n     * @return {number} The polygon's moment of inertia\n     */\n    Vertices.inertia = function(vertices, mass) {\n        var numerator = 0,\n            denominator = 0,\n            v = vertices,\n            cross,\n            j;\n\n        // find the polygon's moment of inertia, using second moment of area\n        // from equations at http://www.physicsforums.com/showthread.php?t=25293\n        for (var n = 0; n < v.length; n++) {\n            j = (n + 1) % v.length;\n            cross = Math.abs(Vector.cross(v[j], v[n]));\n            numerator += cross * (Vector.dot(v[j], v[j]) + Vector.dot(v[j], v[n]) + Vector.dot(v[n], v[n]));\n            denominator += cross;\n        }\n\n        return (mass / 6) * (numerator / denominator);\n    };\n\n    /**\n     * Translates the set of vertices in-place.\n     * @method translate\n     * @param {vertices} vertices\n     * @param {vector} vector\n     * @param {number} scalar\n     */\n    Vertices.translate = function(vertices, vector, scalar) {\n        var i;\n        if (scalar) {\n            for (i = 0; i < vertices.length; i++) {\n                vertices[i].x += vector.x * scalar;\n                vertices[i].y += vector.y * scalar;\n            }\n        } else {\n            for (i = 0; i < vertices.length; i++) {\n                vertices[i].x += vector.x;\n                vertices[i].y += vector.y;\n            }\n        }\n\n        return vertices;\n    };\n\n    /**\n     * Rotates the set of vertices in-place.\n     * @method rotate\n     * @param {vertices} vertices\n     * @param {number} angle\n     * @param {vector} point\n     */\n    Vertices.rotate = function(vertices, angle, point) {\n        if (angle === 0)\n            return;\n\n        var cos = Math.cos(angle),\n            sin = Math.sin(angle);\n\n        for (var i = 0; i < vertices.length; i++) {\n            var vertice = vertices[i],\n                dx = vertice.x - point.x,\n                dy = vertice.y - point.y;\n                \n            vertice.x = point.x + (dx * cos - dy * sin);\n            vertice.y = point.y + (dx * sin + dy * cos);\n        }\n\n        return vertices;\n    };\n\n    /**\n     * Returns `true` if the `point` is inside the set of `vertices`.\n     * @method contains\n     * @param {vertices} vertices\n     * @param {vector} point\n     * @return {boolean} True if the vertices contains point, otherwise false\n     */\n    Vertices.contains = function(vertices, point) {\n        for (var i = 0; i < vertices.length; i++) {\n            var vertice = vertices[i],\n                nextVertice = vertices[(i + 1) % vertices.length];\n            if ((point.x - vertice.x) * (nextVertice.y - vertice.y) + (point.y - vertice.y) * (vertice.x - nextVertice.x) > 0) {\n                return false;\n            }\n        }\n\n        return true;\n    };\n\n    /**\n     * Scales the vertices from a point (default is centre) in-place.\n     * @method scale\n     * @param {vertices} vertices\n     * @param {number} scaleX\n     * @param {number} scaleY\n     * @param {vector} point\n     */\n    Vertices.scale = function(vertices, scaleX, scaleY, point) {\n        if (scaleX === 1 && scaleY === 1)\n            return vertices;\n\n        point = point || Vertices.centre(vertices);\n\n        var vertex,\n            delta;\n\n        for (var i = 0; i < vertices.length; i++) {\n            vertex = vertices[i];\n            delta = Vector.sub(vertex, point);\n            vertices[i].x = point.x + delta.x * scaleX;\n            vertices[i].y = point.y + delta.y * scaleY;\n        }\n\n        return vertices;\n    };\n\n    /**\n     * Chamfers a set of vertices by giving them rounded corners, returns a new set of vertices.\n     * The radius parameter is a single number or an array to specify the radius for each vertex.\n     * @method chamfer\n     * @param {vertices} vertices\n     * @param {number[]} radius\n     * @param {number} quality\n     * @param {number} qualityMin\n     * @param {number} qualityMax\n     */\n    Vertices.chamfer = function(vertices, radius, quality, qualityMin, qualityMax) {\n        if (typeof radius === 'number') {\n            radius = [radius];\n        } else {\n            radius = radius || [8];\n        }\n\n        // quality defaults to -1, which is auto\n        quality = (typeof quality !== 'undefined') ? quality : -1;\n        qualityMin = qualityMin || 2;\n        qualityMax = qualityMax || 14;\n\n        var newVertices = [];\n\n        for (var i = 0; i < vertices.length; i++) {\n            var prevVertex = vertices[i - 1 >= 0 ? i - 1 : vertices.length - 1],\n                vertex = vertices[i],\n                nextVertex = vertices[(i + 1) % vertices.length],\n                currentRadius = radius[i < radius.length ? i : radius.length - 1];\n\n            if (currentRadius === 0) {\n                newVertices.push(vertex);\n                continue;\n            }\n\n            var prevNormal = Vector.normalise({ \n                x: vertex.y - prevVertex.y, \n                y: prevVertex.x - vertex.x\n            });\n\n            var nextNormal = Vector.normalise({ \n                x: nextVertex.y - vertex.y, \n                y: vertex.x - nextVertex.x\n            });\n\n            var diagonalRadius = Math.sqrt(2 * Math.pow(currentRadius, 2)),\n                radiusVector = Vector.mult(Common.clone(prevNormal), currentRadius),\n                midNormal = Vector.normalise(Vector.mult(Vector.add(prevNormal, nextNormal), 0.5)),\n                scaledVertex = Vector.sub(vertex, Vector.mult(midNormal, diagonalRadius));\n\n            var precision = quality;\n\n            if (quality === -1) {\n                // automatically decide precision\n                precision = Math.pow(currentRadius, 0.32) * 1.75;\n            }\n\n            precision = Common.clamp(precision, qualityMin, qualityMax);\n\n            // use an even value for precision, more likely to reduce axes by using symmetry\n            if (precision % 2 === 1)\n                precision += 1;\n\n            var alpha = Math.acos(Vector.dot(prevNormal, nextNormal)),\n                theta = alpha / precision;\n\n            for (var j = 0; j < precision; j++) {\n                newVertices.push(Vector.add(Vector.rotate(radiusVector, theta * j), scaledVertex));\n            }\n        }\n\n        return newVertices;\n    };\n\n    /**\n     * Sorts the input vertices into clockwise order in place.\n     * @method clockwiseSort\n     * @param {vertices} vertices\n     * @return {vertices} vertices\n     */\n    Vertices.clockwiseSort = function(vertices) {\n        var centre = Vertices.mean(vertices);\n\n        vertices.sort(function(vertexA, vertexB) {\n            return Vector.angle(centre, vertexA) - Vector.angle(centre, vertexB);\n        });\n\n        return vertices;\n    };\n\n    /**\n     * Returns true if the vertices form a convex shape (vertices must be in clockwise order).\n     * @method isConvex\n     * @param {vertices} vertices\n     * @return {bool} `true` if the `vertices` are convex, `false` if not (or `null` if not computable).\n     */\n    Vertices.isConvex = function(vertices) {\n        // http://paulbourke.net/geometry/polygonmesh/\n        // Copyright (c) Paul Bourke (use permitted)\n\n        var flag = 0,\n            n = vertices.length,\n            i,\n            j,\n            k,\n            z;\n\n        if (n < 3)\n            return null;\n\n        for (i = 0; i < n; i++) {\n            j = (i + 1) % n;\n            k = (i + 2) % n;\n            z = (vertices[j].x - vertices[i].x) * (vertices[k].y - vertices[j].y);\n            z -= (vertices[j].y - vertices[i].y) * (vertices[k].x - vertices[j].x);\n\n            if (z < 0) {\n                flag |= 1;\n            } else if (z > 0) {\n                flag |= 2;\n            }\n\n            if (flag === 3) {\n                return false;\n            }\n        }\n\n        if (flag !== 0){\n            return true;\n        } else {\n            return null;\n        }\n    };\n\n    /**\n     * Returns the convex hull of the input vertices as a new array of points.\n     * @method hull\n     * @param {vertices} vertices\n     * @return [vertex] vertices\n     */\n    Vertices.hull = function(vertices) {\n        // http://geomalgorithms.com/a10-_hull-1.html\n\n        var upper = [],\n            lower = [], \n            vertex,\n            i;\n\n        // sort vertices on x-axis (y-axis for ties)\n        vertices = vertices.slice(0);\n        vertices.sort(function(vertexA, vertexB) {\n            var dx = vertexA.x - vertexB.x;\n            return dx !== 0 ? dx : vertexA.y - vertexB.y;\n        });\n\n        // build lower hull\n        for (i = 0; i < vertices.length; i += 1) {\n            vertex = vertices[i];\n\n            while (lower.length >= 2 \n                   && Vector.cross3(lower[lower.length - 2], lower[lower.length - 1], vertex) <= 0) {\n                lower.pop();\n            }\n\n            lower.push(vertex);\n        }\n\n        // build upper hull\n        for (i = vertices.length - 1; i >= 0; i -= 1) {\n            vertex = vertices[i];\n\n            while (upper.length >= 2 \n                   && Vector.cross3(upper[upper.length - 2], upper[upper.length - 1], vertex) <= 0) {\n                upper.pop();\n            }\n\n            upper.push(vertex);\n        }\n\n        // concatenation of the lower and upper hulls gives the convex hull\n        // omit last points because they are repeated at the beginning of the other list\n        upper.pop();\n        lower.pop();\n\n        return upper.concat(lower);\n    };\n\n})();\n\n},{\"../core/Common\":14,\"../geometry/Vector\":28}],30:[function(_dereq_,module,exports){\nvar Matter = module.exports = _dereq_('../core/Matter');\n\nMatter.Body = _dereq_('../body/Body');\nMatter.Composite = _dereq_('../body/Composite');\nMatter.World = _dereq_('../body/World');\n\nMatter.Contact = _dereq_('../collision/Contact');\nMatter.Detector = _dereq_('../collision/Detector');\nMatter.Grid = _dereq_('../collision/Grid');\nMatter.Pairs = _dereq_('../collision/Pairs');\nMatter.Pair = _dereq_('../collision/Pair');\nMatter.Query = _dereq_('../collision/Query');\nMatter.Resolver = _dereq_('../collision/Resolver');\nMatter.SAT = _dereq_('../collision/SAT');\n\nMatter.Constraint = _dereq_('../constraint/Constraint');\nMatter.MouseConstraint = _dereq_('../constraint/MouseConstraint');\n\nMatter.Common = _dereq_('../core/Common');\nMatter.Engine = _dereq_('../core/Engine');\nMatter.Events = _dereq_('../core/Events');\nMatter.Mouse = _dereq_('../core/Mouse');\nMatter.Runner = _dereq_('../core/Runner');\nMatter.Sleeping = _dereq_('../core/Sleeping');\nMatter.Plugin = _dereq_('../core/Plugin');\n\n\nMatter.Bodies = _dereq_('../factory/Bodies');\nMatter.Composites = _dereq_('../factory/Composites');\n\nMatter.Axes = _dereq_('../geometry/Axes');\nMatter.Bounds = _dereq_('../geometry/Bounds');\nMatter.Svg = _dereq_('../geometry/Svg');\nMatter.Vector = _dereq_('../geometry/Vector');\nMatter.Vertices = _dereq_('../geometry/Vertices');\n\nMatter.Render = _dereq_('../render/Render');\nMatter.RenderPixi = _dereq_('../render/RenderPixi');\n\n// aliases\n\nMatter.World.add = Matter.Composite.add;\nMatter.World.remove = Matter.Composite.remove;\nMatter.World.addComposite = Matter.Composite.addComposite;\nMatter.World.addBody = Matter.Composite.addBody;\nMatter.World.addConstraint = Matter.Composite.addConstraint;\nMatter.World.clear = Matter.Composite.clear;\nMatter.Engine.run = Matter.Runner.run;\n\n},{\"../body/Body\":1,\"../body/Composite\":2,\"../body/World\":3,\"../collision/Contact\":4,\"../collision/Detector\":5,\"../collision/Grid\":6,\"../collision/Pair\":7,\"../collision/Pairs\":8,\"../collision/Query\":9,\"../collision/Resolver\":10,\"../collision/SAT\":11,\"../constraint/Constraint\":12,\"../constraint/MouseConstraint\":13,\"../core/Common\":14,\"../core/Engine\":15,\"../core/Events\":16,\"../core/Matter\":17,\"../core/Metrics\":18,\"../core/Mouse\":19,\"../core/Plugin\":20,\"../core/Runner\":21,\"../core/Sleeping\":22,\"../factory/Bodies\":23,\"../factory/Composites\":24,\"../geometry/Axes\":25,\"../geometry/Bounds\":26,\"../geometry/Svg\":27,\"../geometry/Vector\":28,\"../geometry/Vertices\":29,\"../render/Render\":31,\"../render/RenderPixi\":32}],31:[function(_dereq_,module,exports){\n/**\n* The `Matter.Render` module is a simple HTML5 canvas based renderer for visualising instances of `Matter.Engine`.\n* It is intended for development and debugging purposes, but may also be suitable for simple games.\n* It includes a number of drawing options including wireframe, vector with support for sprites and viewports.\n*\n* @class Render\n*/\n\nvar Render = {};\n\nmodule.exports = Render;\n\nvar Common = _dereq_('../core/Common');\nvar Composite = _dereq_('../body/Composite');\nvar Bounds = _dereq_('../geometry/Bounds');\nvar Events = _dereq_('../core/Events');\nvar Grid = _dereq_('../collision/Grid');\nvar Vector = _dereq_('../geometry/Vector');\nvar Mouse = _dereq_('../core/Mouse');\n\n(function() {\n\n    var _requestAnimationFrame,\n        _cancelAnimationFrame;\n\n    if (typeof window !== 'undefined') {\n        _requestAnimationFrame = window.requestAnimationFrame || window.webkitRequestAnimationFrame\n                                      || window.mozRequestAnimationFrame || window.msRequestAnimationFrame\n                                      || function(callback){ window.setTimeout(function() { callback(Common.now()); }, 1000 / 60); };\n\n        _cancelAnimationFrame = window.cancelAnimationFrame || window.mozCancelAnimationFrame\n                                      || window.webkitCancelAnimationFrame || window.msCancelAnimationFrame;\n    }\n\n    /**\n     * Creates a new renderer. The options parameter is an object that specifies any properties you wish to override the defaults.\n     * All properties have default values, and many are pre-calculated automatically based on other properties.\n     * See the properties section below for detailed information on what you can pass via the `options` object.\n     * @method create\n     * @param {object} [options]\n     * @return {render} A new renderer\n     */\n    Render.create = function(options) {\n        var defaults = {\n            controller: Render,\n            engine: null,\n            element: null,\n            canvas: null,\n            mouse: null,\n            frameRequestId: null,\n            options: {\n                width: 800,\n                height: 600,\n                pixelRatio: 1,\n                background: '#18181d',\n                wireframeBackground: '#0f0f13',\n                hasBounds: !!options.bounds,\n                enabled: true,\n                wireframes: true,\n                showSleeping: true,\n                showDebug: false,\n                showBroadphase: false,\n                showBounds: false,\n                showVelocity: false,\n                showCollisions: false,\n                showSeparations: false,\n                showAxes: false,\n                showPositions: false,\n                showAngleIndicator: false,\n                showIds: false,\n                showShadows: false,\n                showVertexNumbers: false,\n                showConvexHulls: false,\n                showInternalEdges: false,\n                showMousePosition: false\n            }\n        };\n\n        var render = Common.extend(defaults, options);\n\n        if (render.canvas) {\n            render.canvas.width = render.options.width || render.canvas.width;\n            render.canvas.height = render.options.height || render.canvas.height;\n        }\n\n        render.mouse = options.mouse;\n        render.engine = options.engine;\n        render.canvas = render.canvas || _createCanvas(render.options.width, render.options.height);\n        render.context = render.canvas.getContext('2d');\n        render.textures = {};\n\n        render.bounds = render.bounds || {\n            min: {\n                x: 0,\n                y: 0\n            },\n            max: {\n                x: render.canvas.width,\n                y: render.canvas.height\n            }\n        };\n\n        if (render.options.pixelRatio !== 1) {\n            Render.setPixelRatio(render, render.options.pixelRatio);\n        }\n\n        if (Common.isElement(render.element)) {\n            render.element.appendChild(render.canvas);\n        } else if (!render.canvas.parentNode) {\n            Common.log('Render.create: options.element was undefined, render.canvas was created but not appended', 'warn');\n        }\n\n        return render;\n    };\n\n    /**\n     * Continuously updates the render canvas on the `requestAnimationFrame` event.\n     * @method run\n     * @param {render} render\n     */\n    Render.run = function(render) {\n        (function loop(time){\n            render.frameRequestId = _requestAnimationFrame(loop);\n            Render.world(render);\n        })();\n    };\n\n    /**\n     * Ends execution of `Render.run` on the given `render`, by canceling the animation frame request event loop.\n     * @method stop\n     * @param {render} render\n     */\n    Render.stop = function(render) {\n        _cancelAnimationFrame(render.frameRequestId);\n    };\n\n    /**\n     * Sets the pixel ratio of the renderer and updates the canvas.\n     * To automatically detect the correct ratio, pass the string `'auto'` for `pixelRatio`.\n     * @method setPixelRatio\n     * @param {render} render\n     * @param {number} pixelRatio\n     */\n    Render.setPixelRatio = function(render, pixelRatio) {\n        var options = render.options,\n            canvas = render.canvas;\n\n        if (pixelRatio === 'auto') {\n            pixelRatio = _getPixelRatio(canvas);\n        }\n\n        options.pixelRatio = pixelRatio;\n        canvas.setAttribute('data-pixel-ratio', pixelRatio);\n        canvas.width = options.width * pixelRatio;\n        canvas.height = options.height * pixelRatio;\n        canvas.style.width = options.width + 'px';\n        canvas.style.height = options.height + 'px';\n        render.context.scale(pixelRatio, pixelRatio);\n    };\n\n    /**\n     * Positions and sizes the viewport around the given object bounds.\n     * Objects must have at least one of the following properties:\n     * - `object.bounds`\n     * - `object.position`\n     * - `object.min` and `object.max`\n     * - `object.x` and `object.y`\n     * @method lookAt\n     * @param {render} render\n     * @param {object[]} objects\n     * @param {vector} [padding]\n     * @param {bool} [center=true]\n     */\n    Render.lookAt = function(render, objects, padding, center) {\n        center = typeof center !== 'undefined' ? center : true;\n        objects = Common.isArray(objects) ? objects : [objects];\n        padding = padding || {\n            x: 0,\n            y: 0\n        };\n\n        // find bounds of all objects\n        var bounds = {\n            min: { x: Infinity, y: Infinity },\n            max: { x: -Infinity, y: -Infinity }\n        };\n\n        for (var i = 0; i < objects.length; i += 1) {\n            var object = objects[i],\n                min = object.bounds ? object.bounds.min : (object.min || object.position || object),\n                max = object.bounds ? object.bounds.max : (object.max || object.position || object);\n\n            if (min && max) {\n                if (min.x < bounds.min.x)\n                    bounds.min.x = min.x;\n\n                if (max.x > bounds.max.x)\n                    bounds.max.x = max.x;\n\n                if (min.y < bounds.min.y)\n                    bounds.min.y = min.y;\n\n                if (max.y > bounds.max.y)\n                    bounds.max.y = max.y;\n            }\n        }\n\n        // find ratios\n        var width = (bounds.max.x - bounds.min.x) + 2 * padding.x,\n            height = (bounds.max.y - bounds.min.y) + 2 * padding.y,\n            viewHeight = render.canvas.height,\n            viewWidth = render.canvas.width,\n            outerRatio = viewWidth / viewHeight,\n            innerRatio = width / height,\n            scaleX = 1,\n            scaleY = 1;\n\n        // find scale factor\n        if (innerRatio > outerRatio) {\n            scaleY = innerRatio / outerRatio;\n        } else {\n            scaleX = outerRatio / innerRatio;\n        }\n\n        // enable bounds\n        render.options.hasBounds = true;\n\n        // position and size\n        render.bounds.min.x = bounds.min.x;\n        render.bounds.max.x = bounds.min.x + width * scaleX;\n        render.bounds.min.y = bounds.min.y;\n        render.bounds.max.y = bounds.min.y + height * scaleY;\n\n        // center\n        if (center) {\n            render.bounds.min.x += width * 0.5 - (width * scaleX) * 0.5;\n            render.bounds.max.x += width * 0.5 - (width * scaleX) * 0.5;\n            render.bounds.min.y += height * 0.5 - (height * scaleY) * 0.5;\n            render.bounds.max.y += height * 0.5 - (height * scaleY) * 0.5;\n        }\n\n        // padding\n        render.bounds.min.x -= padding.x;\n        render.bounds.max.x -= padding.x;\n        render.bounds.min.y -= padding.y;\n        render.bounds.max.y -= padding.y;\n\n        // update mouse\n        if (render.mouse) {\n            Mouse.setScale(render.mouse, {\n                x: (render.bounds.max.x - render.bounds.min.x) / render.canvas.width,\n                y: (render.bounds.max.y - render.bounds.min.y) / render.canvas.height\n            });\n\n            Mouse.setOffset(render.mouse, render.bounds.min);\n        }\n    };\n\n    /**\n     * Applies viewport transforms based on `render.bounds` to a render context.\n     * @method startViewTransform\n     * @param {render} render\n     */\n    Render.startViewTransform = function(render) {\n        var boundsWidth = render.bounds.max.x - render.bounds.min.x,\n            boundsHeight = render.bounds.max.y - render.bounds.min.y,\n            boundsScaleX = boundsWidth / render.options.width,\n            boundsScaleY = boundsHeight / render.options.height;\n\n        render.context.scale(1 / boundsScaleX, 1 / boundsScaleY);\n        render.context.translate(-render.bounds.min.x, -render.bounds.min.y);\n    };\n\n    /**\n     * Resets all transforms on the render context.\n     * @method endViewTransform\n     * @param {render} render\n     */\n    Render.endViewTransform = function(render) {\n        render.context.setTransform(render.options.pixelRatio, 0, 0, render.options.pixelRatio, 0, 0);\n    };\n\n    /**\n     * Renders the given `engine`'s `Matter.World` object.\n     * This is the entry point for all rendering and should be called every time the scene changes.\n     * @method world\n     * @param {render} render\n     */\n    Render.world = function(render) {\n        var engine = render.engine,\n            world = engine.world,\n            canvas = render.canvas,\n            context = render.context,\n            options = render.options,\n            allBodies = Composite.allBodies(world),\n            allConstraints = Composite.allConstraints(world),\n            background = options.wireframes ? options.wireframeBackground : options.background,\n            bodies = [],\n            constraints = [],\n            i;\n\n        var event = {\n            timestamp: engine.timing.timestamp\n        };\n\n        Events.trigger(render, 'beforeRender', event);\n\n        // apply background if it has changed\n        if (render.currentBackground !== background)\n            _applyBackground(render, background);\n\n        // clear the canvas with a transparent fill, to allow the canvas background to show\n        context.globalCompositeOperation = 'source-in';\n        context.fillStyle = \"transparent\";\n        context.fillRect(0, 0, canvas.width, canvas.height);\n        context.globalCompositeOperation = 'source-over';\n\n        // handle bounds\n        if (options.hasBounds) {\n            // filter out bodies that are not in view\n            for (i = 0; i < allBodies.length; i++) {\n                var body = allBodies[i];\n                if (Bounds.overlaps(body.bounds, render.bounds))\n                    bodies.push(body);\n            }\n\n            // filter out constraints that are not in view\n            for (i = 0; i < allConstraints.length; i++) {\n                var constraint = allConstraints[i],\n                    bodyA = constraint.bodyA,\n                    bodyB = constraint.bodyB,\n                    pointAWorld = constraint.pointA,\n                    pointBWorld = constraint.pointB;\n\n                if (bodyA) pointAWorld = Vector.add(bodyA.position, constraint.pointA);\n                if (bodyB) pointBWorld = Vector.add(bodyB.position, constraint.pointB);\n\n                if (!pointAWorld || !pointBWorld)\n                    continue;\n\n                if (Bounds.contains(render.bounds, pointAWorld) || Bounds.contains(render.bounds, pointBWorld))\n                    constraints.push(constraint);\n            }\n\n            // transform the view\n            Render.startViewTransform(render);\n\n            // update mouse\n            if (render.mouse) {\n                Mouse.setScale(render.mouse, {\n                    x: (render.bounds.max.x - render.bounds.min.x) / render.canvas.width,\n                    y: (render.bounds.max.y - render.bounds.min.y) / render.canvas.height\n                });\n\n                Mouse.setOffset(render.mouse, render.bounds.min);\n            }\n        } else {\n            constraints = allConstraints;\n            bodies = allBodies;\n        }\n\n        if (!options.wireframes || (engine.enableSleeping && options.showSleeping)) {\n            // fully featured rendering of bodies\n            Render.bodies(render, bodies, context);\n        } else {\n            if (options.showConvexHulls)\n                Render.bodyConvexHulls(render, bodies, context);\n\n            // optimised method for wireframes only\n            Render.bodyWireframes(render, bodies, context);\n        }\n\n        if (options.showBounds)\n            Render.bodyBounds(render, bodies, context);\n\n        if (options.showAxes || options.showAngleIndicator)\n            Render.bodyAxes(render, bodies, context);\n\n        if (options.showPositions)\n            Render.bodyPositions(render, bodies, context);\n\n        if (options.showVelocity)\n            Render.bodyVelocity(render, bodies, context);\n\n        if (options.showIds)\n            Render.bodyIds(render, bodies, context);\n\n        if (options.showSeparations)\n            Render.separations(render, engine.pairs.list, context);\n\n        if (options.showCollisions)\n            Render.collisions(render, engine.pairs.list, context);\n\n        if (options.showVertexNumbers)\n            Render.vertexNumbers(render, bodies, context);\n\n        if (options.showMousePosition)\n            Render.mousePosition(render, render.mouse, context);\n\n        Render.constraints(constraints, context);\n\n        if (options.showBroadphase && engine.broadphase.controller === Grid)\n            Render.grid(render, engine.broadphase, context);\n\n        if (options.showDebug)\n            Render.debug(render, context);\n\n        if (options.hasBounds) {\n            // revert view transforms\n            Render.endViewTransform(render);\n        }\n\n        Events.trigger(render, 'afterRender', event);\n    };\n\n    /**\n     * Description\n     * @private\n     * @method debug\n     * @param {render} render\n     * @param {RenderingContext} context\n     */\n    Render.debug = function(render, context) {\n        var c = context,\n            engine = render.engine,\n            world = engine.world,\n            metrics = engine.metrics,\n            options = render.options,\n            bodies = Composite.allBodies(world),\n            space = \"    \";\n\n        if (engine.timing.timestamp - (render.debugTimestamp || 0) >= 500) {\n            var text = \"\";\n\n            if (metrics.timing) {\n                text += \"fps: \" + Math.round(metrics.timing.fps) + space;\n            }\n\n\n            render.debugString = text;\n            render.debugTimestamp = engine.timing.timestamp;\n        }\n\n        if (render.debugString) {\n            c.font = \"12px Arial\";\n\n            if (options.wireframes) {\n                c.fillStyle = 'rgba(255,255,255,0.5)';\n            } else {\n                c.fillStyle = 'rgba(0,0,0,0.5)';\n            }\n\n            var split = render.debugString.split('\\n');\n\n            for (var i = 0; i < split.length; i++) {\n                c.fillText(split[i], 50, 50 + i * 18);\n            }\n        }\n    };\n\n    /**\n     * Description\n     * @private\n     * @method constraints\n     * @param {constraint[]} constraints\n     * @param {RenderingContext} context\n     */\n    Render.constraints = function(constraints, context) {\n        var c = context;\n\n        for (var i = 0; i < constraints.length; i++) {\n            var constraint = constraints[i];\n\n            if (!constraint.render.visible || !constraint.pointA || !constraint.pointB)\n                continue;\n\n            var bodyA = constraint.bodyA,\n                bodyB = constraint.bodyB,\n                start,\n                end;\n\n            if (bodyA) {\n                start = Vector.add(bodyA.position, constraint.pointA);\n            } else {\n                start = constraint.pointA;\n            }\n\n            if (constraint.render.type === 'pin') {\n                c.beginPath();\n                c.arc(start.x, start.y, 3, 0, 2 * Math.PI);\n                c.closePath();\n            } else {\n                if (bodyB) {\n                    end = Vector.add(bodyB.position, constraint.pointB);\n                } else {\n                    end = constraint.pointB;\n                }\n\n                c.beginPath();\n                c.moveTo(start.x, start.y);\n\n                if (constraint.render.type === 'spring') {\n                    var delta = Vector.sub(end, start),\n                        normal = Vector.perp(Vector.normalise(delta)),\n                        coils = Math.ceil(Common.clamp(constraint.length / 5, 12, 20)),\n                        offset;\n\n                    for (var j = 1; j < coils; j += 1) {\n                        offset = j % 2 === 0 ? 1 : -1;\n\n                        c.lineTo(\n                            start.x + delta.x * (j / coils) + normal.x * offset * 4,\n                            start.y + delta.y * (j / coils) + normal.y * offset * 4\n                        );\n                    }\n                }\n\n                c.lineTo(end.x, end.y);\n            }\n\n            if (constraint.render.lineWidth) {\n                c.lineWidth = constraint.render.lineWidth;\n                c.strokeStyle = constraint.render.strokeStyle;\n                c.stroke();\n            }\n\n            if (constraint.render.anchors) {\n                c.fillStyle = constraint.render.strokeStyle;\n                c.beginPath();\n                c.arc(start.x, start.y, 3, 0, 2 * Math.PI);\n                c.arc(end.x, end.y, 3, 0, 2 * Math.PI);\n                c.closePath();\n                c.fill();\n            }\n        }\n    };\n\n    /**\n     * Description\n     * @private\n     * @method bodyShadows\n     * @param {render} render\n     * @param {body[]} bodies\n     * @param {RenderingContext} context\n     */\n    Render.bodyShadows = function(render, bodies, context) {\n        var c = context,\n            engine = render.engine;\n\n        for (var i = 0; i < bodies.length; i++) {\n            var body = bodies[i];\n\n            if (!body.render.visible)\n                continue;\n\n            if (body.circleRadius) {\n                c.beginPath();\n                c.arc(body.position.x, body.position.y, body.circleRadius, 0, 2 * Math.PI);\n                c.closePath();\n            } else {\n                c.beginPath();\n                c.moveTo(body.vertices[0].x, body.vertices[0].y);\n                for (var j = 1; j < body.vertices.length; j++) {\n                    c.lineTo(body.vertices[j].x, body.vertices[j].y);\n                }\n                c.closePath();\n            }\n\n            var distanceX = body.position.x - render.options.width * 0.5,\n                distanceY = body.position.y - render.options.height * 0.2,\n                distance = Math.abs(distanceX) + Math.abs(distanceY);\n\n            c.shadowColor = 'rgba(0,0,0,0.15)';\n            c.shadowOffsetX = 0.05 * distanceX;\n            c.shadowOffsetY = 0.05 * distanceY;\n            c.shadowBlur = 1 + 12 * Math.min(1, distance / 1000);\n\n            c.fill();\n\n            c.shadowColor = null;\n            c.shadowOffsetX = null;\n            c.shadowOffsetY = null;\n            c.shadowBlur = null;\n        }\n    };\n\n    /**\n     * Description\n     * @private\n     * @method bodies\n     * @param {render} render\n     * @param {body[]} bodies\n     * @param {RenderingContext} context\n     */\n    Render.bodies = function(render, bodies, context) {\n        var c = context,\n            engine = render.engine,\n            options = render.options,\n            showInternalEdges = options.showInternalEdges || !options.wireframes,\n            body,\n            part,\n            i,\n            k;\n\n        for (i = 0; i < bodies.length; i++) {\n            body = bodies[i];\n\n            if (!body.render.visible)\n                continue;\n\n            // handle compound parts\n            for (k = body.parts.length > 1 ? 1 : 0; k < body.parts.length; k++) {\n                part = body.parts[k];\n\n                if (!part.render.visible)\n                    continue;\n\n                if (options.showSleeping && body.isSleeping) {\n                    c.globalAlpha = 0.5 * part.render.opacity;\n                } else if (part.render.opacity !== 1) {\n                    c.globalAlpha = part.render.opacity;\n                }\n\n                if (part.render.sprite && part.render.sprite.texture && !options.wireframes) {\n                    // part sprite\n                    var sprite = part.render.sprite,\n                        texture = _getTexture(render, sprite.texture);\n\n                    c.translate(part.position.x, part.position.y);\n                    c.rotate(part.angle);\n\n                    c.drawImage(\n                        texture,\n                        texture.width * -sprite.xOffset * sprite.xScale,\n                        texture.height * -sprite.yOffset * sprite.yScale,\n                        texture.width * sprite.xScale,\n                        texture.height * sprite.yScale\n                    );\n\n                    // revert translation, hopefully faster than save / restore\n                    c.rotate(-part.angle);\n                    c.translate(-part.position.x, -part.position.y);\n                } else {\n                    // part polygon\n                    if (part.circleRadius) {\n                        c.beginPath();\n                        c.arc(part.position.x, part.position.y, part.circleRadius, 0, 2 * Math.PI);\n                    } else {\n                        c.beginPath();\n                        c.moveTo(part.vertices[0].x, part.vertices[0].y);\n\n                        for (var j = 1; j < part.vertices.length; j++) {\n                            if (!part.vertices[j - 1].isInternal || showInternalEdges) {\n                                c.lineTo(part.vertices[j].x, part.vertices[j].y);\n                            } else {\n                                c.moveTo(part.vertices[j].x, part.vertices[j].y);\n                            }\n\n                            if (part.vertices[j].isInternal && !showInternalEdges) {\n                                c.moveTo(part.vertices[(j + 1) % part.vertices.length].x, part.vertices[(j + 1) % part.vertices.length].y);\n                            }\n                        }\n\n                        c.lineTo(part.vertices[0].x, part.vertices[0].y);\n                        c.closePath();\n                    }\n\n                    if (!options.wireframes) {\n                        c.fillStyle = part.render.fillStyle;\n\n                        if (part.render.lineWidth) {\n                            c.lineWidth = part.render.lineWidth;\n                            c.strokeStyle = part.render.strokeStyle;\n                            c.stroke();\n                        }\n\n                        c.fill();\n                    } else {\n                        c.lineWidth = 1;\n                        c.strokeStyle = '#bbb';\n                        c.stroke();\n                    }\n                }\n\n                c.globalAlpha = 1;\n            }\n        }\n    };\n\n    /**\n     * Optimised method for drawing body wireframes in one pass\n     * @private\n     * @method bodyWireframes\n     * @param {render} render\n     * @param {body[]} bodies\n     * @param {RenderingContext} context\n     */\n    Render.bodyWireframes = function(render, bodies, context) {\n        var c = context,\n            showInternalEdges = render.options.showInternalEdges,\n            body,\n            part,\n            i,\n            j,\n            k;\n\n        c.beginPath();\n\n        // render all bodies\n        for (i = 0; i < bodies.length; i++) {\n            body = bodies[i];\n\n            if (!body.render.visible)\n                continue;\n\n            // handle compound parts\n            for (k = body.parts.length > 1 ? 1 : 0; k < body.parts.length; k++) {\n                part = body.parts[k];\n\n                c.moveTo(part.vertices[0].x, part.vertices[0].y);\n\n                for (j = 1; j < part.vertices.length; j++) {\n                    if (!part.vertices[j - 1].isInternal || showInternalEdges) {\n                        c.lineTo(part.vertices[j].x, part.vertices[j].y);\n                    } else {\n                        c.moveTo(part.vertices[j].x, part.vertices[j].y);\n                    }\n\n                    if (part.vertices[j].isInternal && !showInternalEdges) {\n                        c.moveTo(part.vertices[(j + 1) % part.vertices.length].x, part.vertices[(j + 1) % part.vertices.length].y);\n                    }\n                }\n\n                c.lineTo(part.vertices[0].x, part.vertices[0].y);\n            }\n        }\n\n        c.lineWidth = 1;\n        c.strokeStyle = '#bbb';\n        c.stroke();\n    };\n\n    /**\n     * Optimised method for drawing body convex hull wireframes in one pass\n     * @private\n     * @method bodyConvexHulls\n     * @param {render} render\n     * @param {body[]} bodies\n     * @param {RenderingContext} context\n     */\n    Render.bodyConvexHulls = function(render, bodies, context) {\n        var c = context,\n            body,\n            part,\n            i,\n            j,\n            k;\n\n        c.beginPath();\n\n        // render convex hulls\n        for (i = 0; i < bodies.length; i++) {\n            body = bodies[i];\n\n            if (!body.render.visible || body.parts.length === 1)\n                continue;\n\n            c.moveTo(body.vertices[0].x, body.vertices[0].y);\n\n            for (j = 1; j < body.vertices.length; j++) {\n                c.lineTo(body.vertices[j].x, body.vertices[j].y);\n            }\n\n            c.lineTo(body.vertices[0].x, body.vertices[0].y);\n        }\n\n        c.lineWidth = 1;\n        c.strokeStyle = 'rgba(255,255,255,0.2)';\n        c.stroke();\n    };\n\n    /**\n     * Renders body vertex numbers.\n     * @private\n     * @method vertexNumbers\n     * @param {render} render\n     * @param {body[]} bodies\n     * @param {RenderingContext} context\n     */\n    Render.vertexNumbers = function(render, bodies, context) {\n        var c = context,\n            i,\n            j,\n            k;\n\n        for (i = 0; i < bodies.length; i++) {\n            var parts = bodies[i].parts;\n            for (k = parts.length > 1 ? 1 : 0; k < parts.length; k++) {\n                var part = parts[k];\n                for (j = 0; j < part.vertices.length; j++) {\n                    c.fillStyle = 'rgba(255,255,255,0.2)';\n                    c.fillText(i + '_' + j, part.position.x + (part.vertices[j].x - part.position.x) * 0.8, part.position.y + (part.vertices[j].y - part.position.y) * 0.8);\n                }\n            }\n        }\n    };\n\n    /**\n     * Renders mouse position.\n     * @private\n     * @method mousePosition\n     * @param {render} render\n     * @param {mouse} mouse\n     * @param {RenderingContext} context\n     */\n    Render.mousePosition = function(render, mouse, context) {\n        var c = context;\n        c.fillStyle = 'rgba(255,255,255,0.8)';\n        c.fillText(mouse.position.x + '  ' + mouse.position.y, mouse.position.x + 5, mouse.position.y - 5);\n    };\n\n    /**\n     * Draws body bounds\n     * @private\n     * @method bodyBounds\n     * @param {render} render\n     * @param {body[]} bodies\n     * @param {RenderingContext} context\n     */\n    Render.bodyBounds = function(render, bodies, context) {\n        var c = context,\n            engine = render.engine,\n            options = render.options;\n\n        c.beginPath();\n\n        for (var i = 0; i < bodies.length; i++) {\n            var body = bodies[i];\n\n            if (body.render.visible) {\n                var parts = bodies[i].parts;\n                for (var j = parts.length > 1 ? 1 : 0; j < parts.length; j++) {\n                    var part = parts[j];\n                    c.rect(part.bounds.min.x, part.bounds.min.y, part.bounds.max.x - part.bounds.min.x, part.bounds.max.y - part.bounds.min.y);\n                }\n            }\n        }\n\n        if (options.wireframes) {\n            c.strokeStyle = 'rgba(255,255,255,0.08)';\n        } else {\n            c.strokeStyle = 'rgba(0,0,0,0.1)';\n        }\n\n        c.lineWidth = 1;\n        c.stroke();\n    };\n\n    /**\n     * Draws body angle indicators and axes\n     * @private\n     * @method bodyAxes\n     * @param {render} render\n     * @param {body[]} bodies\n     * @param {RenderingContext} context\n     */\n    Render.bodyAxes = function(render, bodies, context) {\n        var c = context,\n            engine = render.engine,\n            options = render.options,\n            part,\n            i,\n            j,\n            k;\n\n        c.beginPath();\n\n        for (i = 0; i < bodies.length; i++) {\n            var body = bodies[i],\n                parts = body.parts;\n\n            if (!body.render.visible)\n                continue;\n\n            if (options.showAxes) {\n                // render all axes\n                for (j = parts.length > 1 ? 1 : 0; j < parts.length; j++) {\n                    part = parts[j];\n                    for (k = 0; k < part.axes.length; k++) {\n                        var axis = part.axes[k];\n                        c.moveTo(part.position.x, part.position.y);\n                        c.lineTo(part.position.x + axis.x * 20, part.position.y + axis.y * 20);\n                    }\n                }\n            } else {\n                for (j = parts.length > 1 ? 1 : 0; j < parts.length; j++) {\n                    part = parts[j];\n                    for (k = 0; k < part.axes.length; k++) {\n                        // render a single axis indicator\n                        c.moveTo(part.position.x, part.position.y);\n                        c.lineTo((part.vertices[0].x + part.vertices[part.vertices.length-1].x) / 2,\n                                 (part.vertices[0].y + part.vertices[part.vertices.length-1].y) / 2);\n                    }\n                }\n            }\n        }\n\n        if (options.wireframes) {\n            c.strokeStyle = 'indianred';\n            c.lineWidth = 1;\n        } else {\n            c.strokeStyle = 'rgba(255, 255, 255, 0.4)';\n            c.globalCompositeOperation = 'overlay';\n            c.lineWidth = 2;\n        }\n\n        c.stroke();\n        c.globalCompositeOperation = 'source-over';\n    };\n\n    /**\n     * Draws body positions\n     * @private\n     * @method bodyPositions\n     * @param {render} render\n     * @param {body[]} bodies\n     * @param {RenderingContext} context\n     */\n    Render.bodyPositions = function(render, bodies, context) {\n        var c = context,\n            engine = render.engine,\n            options = render.options,\n            body,\n            part,\n            i,\n            k;\n\n        c.beginPath();\n\n        // render current positions\n        for (i = 0; i < bodies.length; i++) {\n            body = bodies[i];\n\n            if (!body.render.visible)\n                continue;\n\n            // handle compound parts\n            for (k = 0; k < body.parts.length; k++) {\n                part = body.parts[k];\n                c.arc(part.position.x, part.position.y, 3, 0, 2 * Math.PI, false);\n                c.closePath();\n            }\n        }\n\n        if (options.wireframes) {\n            c.fillStyle = 'indianred';\n        } else {\n            c.fillStyle = 'rgba(0,0,0,0.5)';\n        }\n        c.fill();\n\n        c.beginPath();\n\n        // render previous positions\n        for (i = 0; i < bodies.length; i++) {\n            body = bodies[i];\n            if (body.render.visible) {\n                c.arc(body.positionPrev.x, body.positionPrev.y, 2, 0, 2 * Math.PI, false);\n                c.closePath();\n            }\n        }\n\n        c.fillStyle = 'rgba(255,165,0,0.8)';\n        c.fill();\n    };\n\n    /**\n     * Draws body velocity\n     * @private\n     * @method bodyVelocity\n     * @param {render} render\n     * @param {body[]} bodies\n     * @param {RenderingContext} context\n     */\n    Render.bodyVelocity = function(render, bodies, context) {\n        var c = context;\n\n        c.beginPath();\n\n        for (var i = 0; i < bodies.length; i++) {\n            var body = bodies[i];\n\n            if (!body.render.visible)\n                continue;\n\n            c.moveTo(body.position.x, body.position.y);\n            c.lineTo(body.position.x + (body.position.x - body.positionPrev.x) * 2, body.position.y + (body.position.y - body.positionPrev.y) * 2);\n        }\n\n        c.lineWidth = 3;\n        c.strokeStyle = 'cornflowerblue';\n        c.stroke();\n    };\n\n    /**\n     * Draws body ids\n     * @private\n     * @method bodyIds\n     * @param {render} render\n     * @param {body[]} bodies\n     * @param {RenderingContext} context\n     */\n    Render.bodyIds = function(render, bodies, context) {\n        var c = context,\n            i,\n            j;\n\n        for (i = 0; i < bodies.length; i++) {\n            if (!bodies[i].render.visible)\n                continue;\n\n            var parts = bodies[i].parts;\n            for (j = parts.length > 1 ? 1 : 0; j < parts.length; j++) {\n                var part = parts[j];\n                c.font = \"12px Arial\";\n                c.fillStyle = 'rgba(255,255,255,0.5)';\n                c.fillText(part.id, part.position.x + 10, part.position.y - 10);\n            }\n        }\n    };\n\n    /**\n     * Description\n     * @private\n     * @method collisions\n     * @param {render} render\n     * @param {pair[]} pairs\n     * @param {RenderingContext} context\n     */\n    Render.collisions = function(render, pairs, context) {\n        var c = context,\n            options = render.options,\n            pair,\n            collision,\n            corrected,\n            bodyA,\n            bodyB,\n            i,\n            j;\n\n        c.beginPath();\n\n        // render collision positions\n        for (i = 0; i < pairs.length; i++) {\n            pair = pairs[i];\n\n            if (!pair.isActive)\n                continue;\n\n            collision = pair.collision;\n            for (j = 0; j < pair.activeContacts.length; j++) {\n                var contact = pair.activeContacts[j],\n                    vertex = contact.vertex;\n                c.rect(vertex.x - 1.5, vertex.y - 1.5, 3.5, 3.5);\n            }\n        }\n\n        if (options.wireframes) {\n            c.fillStyle = 'rgba(255,255,255,0.7)';\n        } else {\n            c.fillStyle = 'orange';\n        }\n        c.fill();\n\n        c.beginPath();\n\n        // render collision normals\n        for (i = 0; i < pairs.length; i++) {\n            pair = pairs[i];\n\n            if (!pair.isActive)\n                continue;\n\n            collision = pair.collision;\n\n            if (pair.activeContacts.length > 0) {\n                var normalPosX = pair.activeContacts[0].vertex.x,\n                    normalPosY = pair.activeContacts[0].vertex.y;\n\n                if (pair.activeContacts.length === 2) {\n                    normalPosX = (pair.activeContacts[0].vertex.x + pair.activeContacts[1].vertex.x) / 2;\n                    normalPosY = (pair.activeContacts[0].vertex.y + pair.activeContacts[1].vertex.y) / 2;\n                }\n\n                if (collision.bodyB === collision.supports[0].body || collision.bodyA.isStatic === true) {\n                    c.moveTo(normalPosX - collision.normal.x * 8, normalPosY - collision.normal.y * 8);\n                } else {\n                    c.moveTo(normalPosX + collision.normal.x * 8, normalPosY + collision.normal.y * 8);\n                }\n\n                c.lineTo(normalPosX, normalPosY);\n            }\n        }\n\n        if (options.wireframes) {\n            c.strokeStyle = 'rgba(255,165,0,0.7)';\n        } else {\n            c.strokeStyle = 'orange';\n        }\n\n        c.lineWidth = 1;\n        c.stroke();\n    };\n\n    /**\n     * Description\n     * @private\n     * @method separations\n     * @param {render} render\n     * @param {pair[]} pairs\n     * @param {RenderingContext} context\n     */\n    Render.separations = function(render, pairs, context) {\n        var c = context,\n            options = render.options,\n            pair,\n            collision,\n            corrected,\n            bodyA,\n            bodyB,\n            i,\n            j;\n\n        c.beginPath();\n\n        // render separations\n        for (i = 0; i < pairs.length; i++) {\n            pair = pairs[i];\n\n            if (!pair.isActive)\n                continue;\n\n            collision = pair.collision;\n            bodyA = collision.bodyA;\n            bodyB = collision.bodyB;\n\n            var k = 1;\n\n            if (!bodyB.isStatic && !bodyA.isStatic) k = 0.5;\n            if (bodyB.isStatic) k = 0;\n\n            c.moveTo(bodyB.position.x, bodyB.position.y);\n            c.lineTo(bodyB.position.x - collision.penetration.x * k, bodyB.position.y - collision.penetration.y * k);\n\n            k = 1;\n\n            if (!bodyB.isStatic && !bodyA.isStatic) k = 0.5;\n            if (bodyA.isStatic) k = 0;\n\n            c.moveTo(bodyA.position.x, bodyA.position.y);\n            c.lineTo(bodyA.position.x + collision.penetration.x * k, bodyA.position.y + collision.penetration.y * k);\n        }\n\n        if (options.wireframes) {\n            c.strokeStyle = 'rgba(255,165,0,0.5)';\n        } else {\n            c.strokeStyle = 'orange';\n        }\n        c.stroke();\n    };\n\n    /**\n     * Description\n     * @private\n     * @method grid\n     * @param {render} render\n     * @param {grid} grid\n     * @param {RenderingContext} context\n     */\n    Render.grid = function(render, grid, context) {\n        var c = context,\n            options = render.options;\n\n        if (options.wireframes) {\n            c.strokeStyle = 'rgba(255,180,0,0.1)';\n        } else {\n            c.strokeStyle = 'rgba(255,180,0,0.5)';\n        }\n\n        c.beginPath();\n\n        var bucketKeys = Common.keys(grid.buckets);\n\n        for (var i = 0; i < bucketKeys.length; i++) {\n            var bucketId = bucketKeys[i];\n\n            if (grid.buckets[bucketId].length < 2)\n                continue;\n\n            var region = bucketId.split(/C|R/);\n            c.rect(0.5 + parseInt(region[1], 10) * grid.bucketWidth,\n                    0.5 + parseInt(region[2], 10) * grid.bucketHeight,\n                    grid.bucketWidth,\n                    grid.bucketHeight);\n        }\n\n        c.lineWidth = 1;\n        c.stroke();\n    };\n\n    /**\n     * Description\n     * @private\n     * @method inspector\n     * @param {inspector} inspector\n     * @param {RenderingContext} context\n     */\n    Render.inspector = function(inspector, context) {\n        var engine = inspector.engine,\n            selected = inspector.selected,\n            render = inspector.render,\n            options = render.options,\n            bounds;\n\n        if (options.hasBounds) {\n            var boundsWidth = render.bounds.max.x - render.bounds.min.x,\n                boundsHeight = render.bounds.max.y - render.bounds.min.y,\n                boundsScaleX = boundsWidth / render.options.width,\n                boundsScaleY = boundsHeight / render.options.height;\n\n            context.scale(1 / boundsScaleX, 1 / boundsScaleY);\n            context.translate(-render.bounds.min.x, -render.bounds.min.y);\n        }\n\n        for (var i = 0; i < selected.length; i++) {\n            var item = selected[i].data;\n\n            context.translate(0.5, 0.5);\n            context.lineWidth = 1;\n            context.strokeStyle = 'rgba(255,165,0,0.9)';\n            context.setLineDash([1,2]);\n\n            switch (item.type) {\n\n            case 'body':\n\n                // render body selections\n                bounds = item.bounds;\n                context.beginPath();\n                context.rect(Math.floor(bounds.min.x - 3), Math.floor(bounds.min.y - 3),\n                             Math.floor(bounds.max.x - bounds.min.x + 6), Math.floor(bounds.max.y - bounds.min.y + 6));\n                context.closePath();\n                context.stroke();\n\n                break;\n\n            case 'constraint':\n\n                // render constraint selections\n                var point = item.pointA;\n                if (item.bodyA)\n                    point = item.pointB;\n                context.beginPath();\n                context.arc(point.x, point.y, 10, 0, 2 * Math.PI);\n                context.closePath();\n                context.stroke();\n\n                break;\n\n            }\n\n            context.setLineDash([]);\n            context.translate(-0.5, -0.5);\n        }\n\n        // render selection region\n        if (inspector.selectStart !== null) {\n            context.translate(0.5, 0.5);\n            context.lineWidth = 1;\n            context.strokeStyle = 'rgba(255,165,0,0.6)';\n            context.fillStyle = 'rgba(255,165,0,0.1)';\n            bounds = inspector.selectBounds;\n            context.beginPath();\n            context.rect(Math.floor(bounds.min.x), Math.floor(bounds.min.y),\n                         Math.floor(bounds.max.x - bounds.min.x), Math.floor(bounds.max.y - bounds.min.y));\n            context.closePath();\n            context.stroke();\n            context.fill();\n            context.translate(-0.5, -0.5);\n        }\n\n        if (options.hasBounds)\n            context.setTransform(1, 0, 0, 1, 0, 0);\n    };\n\n    /**\n     * Description\n     * @method _createCanvas\n     * @private\n     * @param {} width\n     * @param {} height\n     * @return canvas\n     */\n    var _createCanvas = function(width, height) {\n        var canvas = document.createElement('canvas');\n        canvas.width = width;\n        canvas.height = height;\n        canvas.oncontextmenu = function() { return false; };\n        canvas.onselectstart = function() { return false; };\n        return canvas;\n    };\n\n    /**\n     * Gets the pixel ratio of the canvas.\n     * @method _getPixelRatio\n     * @private\n     * @param {HTMLElement} canvas\n     * @return {Number} pixel ratio\n     */\n    var _getPixelRatio = function(canvas) {\n        var context = canvas.getContext('2d'),\n            devicePixelRatio = window.devicePixelRatio || 1,\n            backingStorePixelRatio = context.webkitBackingStorePixelRatio || context.mozBackingStorePixelRatio\n                                      || context.msBackingStorePixelRatio || context.oBackingStorePixelRatio\n                                      || context.backingStorePixelRatio || 1;\n\n        return devicePixelRatio / backingStorePixelRatio;\n    };\n\n    /**\n     * Gets the requested texture (an Image) via its path\n     * @method _getTexture\n     * @private\n     * @param {render} render\n     * @param {string} imagePath\n     * @return {Image} texture\n     */\n    var _getTexture = function(render, imagePath) {\n        var image = render.textures[imagePath];\n\n        if (image)\n            return image;\n\n        image = render.textures[imagePath] = new Image();\n        image.src = imagePath;\n\n        return image;\n    };\n\n    /**\n     * Applies the background to the canvas using CSS.\n     * @method applyBackground\n     * @private\n     * @param {render} render\n     * @param {string} background\n     */\n    var _applyBackground = function(render, background) {\n        var cssBackground = background;\n\n        if (/(jpg|gif|png)$/.test(background))\n            cssBackground = 'url(' + background + ')';\n\n        render.canvas.style.background = cssBackground;\n        render.canvas.style.backgroundSize = \"contain\";\n        render.currentBackground = background;\n    };\n\n    /*\n    *\n    *  Events Documentation\n    *\n    */\n\n    /**\n    * Fired before rendering\n    *\n    * @event beforeRender\n    * @param {} event An event object\n    * @param {number} event.timestamp The engine.timing.timestamp of the event\n    * @param {} event.source The source object of the event\n    * @param {} event.name The name of the event\n    */\n\n    /**\n    * Fired after rendering\n    *\n    * @event afterRender\n    * @param {} event An event object\n    * @param {number} event.timestamp The engine.timing.timestamp of the event\n    * @param {} event.source The source object of the event\n    * @param {} event.name The name of the event\n    */\n\n    /*\n    *\n    *  Properties Documentation\n    *\n    */\n\n    /**\n     * A back-reference to the `Matter.Render` module.\n     *\n     * @property controller\n     * @type render\n     */\n\n    /**\n     * A reference to the `Matter.Engine` instance to be used.\n     *\n     * @property engine\n     * @type engine\n     */\n\n    /**\n     * A reference to the element where the canvas is to be inserted (if `render.canvas` has not been specified)\n     *\n     * @property element\n     * @type HTMLElement\n     * @default null\n     */\n\n    /**\n     * The canvas element to render to. If not specified, one will be created if `render.element` has been specified.\n     *\n     * @property canvas\n     * @type HTMLCanvasElement\n     * @default null\n     */\n\n    /**\n     * The configuration options of the renderer.\n     *\n     * @property options\n     * @type {}\n     */\n\n    /**\n     * The target width in pixels of the `render.canvas` to be created.\n     *\n     * @property options.width\n     * @type number\n     * @default 800\n     */\n\n    /**\n     * The target height in pixels of the `render.canvas` to be created.\n     *\n     * @property options.height\n     * @type number\n     * @default 600\n     */\n\n    /**\n     * A flag that specifies if `render.bounds` should be used when rendering.\n     *\n     * @property options.hasBounds\n     * @type boolean\n     * @default false\n     */\n\n    /**\n     * A `Bounds` object that specifies the drawing view region.\n     * Rendering will be automatically transformed and scaled to fit within the canvas size (`render.options.width` and `render.options.height`).\n     * This allows for creating views that can pan or zoom around the scene.\n     * You must also set `render.options.hasBounds` to `true` to enable bounded rendering.\n     *\n     * @property bounds\n     * @type bounds\n     */\n\n    /**\n     * The 2d rendering context from the `render.canvas` element.\n     *\n     * @property context\n     * @type CanvasRenderingContext2D\n     */\n\n    /**\n     * The sprite texture cache.\n     *\n     * @property textures\n     * @type {}\n     */\n\n})();\n\n},{\"../body/Composite\":2,\"../collision/Grid\":6,\"../core/Common\":14,\"../core/Events\":16,\"../core/Mouse\":19,\"../geometry/Bounds\":26,\"../geometry/Vector\":28}],32:[function(_dereq_,module,exports){\n/**\n* The `Matter.RenderPixi` module is an example renderer using pixi.js.\n* See also `Matter.Render` for a canvas based renderer.\n*\n* @class RenderPixi\n* @deprecated the Matter.RenderPixi module will soon be removed from the Matter.js core.\n* It will likely be moved to its own repository (but maintenance will be limited).\n*/\n\nvar RenderPixi = {};\n\nmodule.exports = RenderPixi;\n\nvar Bounds = _dereq_('../geometry/Bounds');\nvar Composite = _dereq_('../body/Composite');\nvar Common = _dereq_('../core/Common');\nvar Events = _dereq_('../core/Events');\nvar Vector = _dereq_('../geometry/Vector');\n\n(function() {\n\n    var _requestAnimationFrame,\n        _cancelAnimationFrame;\n\n    if (typeof window !== 'undefined') {\n        _requestAnimationFrame = window.requestAnimationFrame || window.webkitRequestAnimationFrame\n                                      || window.mozRequestAnimationFrame || window.msRequestAnimationFrame \n                                      || function(callback){ window.setTimeout(function() { callback(Common.now()); }, 1000 / 60); };\n   \n        _cancelAnimationFrame = window.cancelAnimationFrame || window.mozCancelAnimationFrame \n                                      || window.webkitCancelAnimationFrame || window.msCancelAnimationFrame;\n    }\n    \n    /**\n     * Creates a new Pixi.js WebGL renderer\n     * @method create\n     * @param {object} options\n     * @return {RenderPixi} A new renderer\n     * @deprecated\n     */\n    RenderPixi.create = function(options) {\n        Common.warn('RenderPixi.create: Matter.RenderPixi is deprecated (see docs)');\n\n        var defaults = {\n            controller: RenderPixi,\n            engine: null,\n            element: null,\n            frameRequestId: null,\n            canvas: null,\n            renderer: null,\n            container: null,\n            spriteContainer: null,\n            pixiOptions: null,\n            options: {\n                width: 800,\n                height: 600,\n                background: '#fafafa',\n                wireframeBackground: '#222',\n                hasBounds: false,\n                enabled: true,\n                wireframes: true,\n                showSleeping: true,\n                showDebug: false,\n                showBroadphase: false,\n                showBounds: false,\n                showVelocity: false,\n                showCollisions: false,\n                showAxes: false,\n                showPositions: false,\n                showAngleIndicator: false,\n                showIds: false,\n                showShadows: false\n            }\n        };\n\n        var render = Common.extend(defaults, options),\n            transparent = !render.options.wireframes && render.options.background === 'transparent';\n\n        // init pixi\n        render.pixiOptions = render.pixiOptions || {\n            view: render.canvas,\n            transparent: transparent,\n            antialias: true,\n            backgroundColor: options.background\n        };\n\n        render.mouse = options.mouse;\n        render.engine = options.engine;\n        render.renderer = render.renderer || new PIXI.WebGLRenderer(render.options.width, render.options.height, render.pixiOptions);\n        render.container = render.container || new PIXI.Container();\n        render.spriteContainer = render.spriteContainer || new PIXI.Container();\n        render.canvas = render.canvas || render.renderer.view;\n        render.bounds = render.bounds || { \n            min: {\n                x: 0,\n                y: 0\n            }, \n            max: { \n                x: render.options.width,\n                y: render.options.height\n            }\n        };\n\n        // event listeners\n        Events.on(render.engine, 'beforeUpdate', function() {\n            RenderPixi.clear(render);\n        });\n\n        // caches\n        render.textures = {};\n        render.sprites = {};\n        render.primitives = {};\n\n        // use a sprite batch for performance\n        render.container.addChild(render.spriteContainer);\n\n        // insert canvas\n        if (Common.isElement(render.element)) {\n            render.element.appendChild(render.canvas);\n        } else {\n            Common.warn('No \"render.element\" passed, \"render.canvas\" was not inserted into document.');\n        }\n\n        // prevent menus on canvas\n        render.canvas.oncontextmenu = function() { return false; };\n        render.canvas.onselectstart = function() { return false; };\n\n        return render;\n    };\n\n    /**\n     * Continuously updates the render canvas on the `requestAnimationFrame` event.\n     * @method run\n     * @param {render} render\n     * @deprecated\n     */\n    RenderPixi.run = function(render) {\n        (function loop(time){\n            render.frameRequestId = _requestAnimationFrame(loop);\n            RenderPixi.world(render);\n        })();\n    };\n\n    /**\n     * Ends execution of `Render.run` on the given `render`, by canceling the animation frame request event loop.\n     * @method stop\n     * @param {render} render\n     * @deprecated\n     */\n    RenderPixi.stop = function(render) {\n        _cancelAnimationFrame(render.frameRequestId);\n    };\n\n    /**\n     * Clears the scene graph\n     * @method clear\n     * @param {RenderPixi} render\n     * @deprecated\n     */\n    RenderPixi.clear = function(render) {\n        var container = render.container,\n            spriteContainer = render.spriteContainer;\n\n        // clear stage container\n        while (container.children[0]) { \n            container.removeChild(container.children[0]); \n        }\n\n        // clear sprite batch\n        while (spriteContainer.children[0]) { \n            spriteContainer.removeChild(spriteContainer.children[0]); \n        }\n\n        var bgSprite = render.sprites['bg-0'];\n\n        // clear caches\n        render.textures = {};\n        render.sprites = {};\n        render.primitives = {};\n\n        // set background sprite\n        render.sprites['bg-0'] = bgSprite;\n        if (bgSprite)\n            container.addChildAt(bgSprite, 0);\n\n        // add sprite batch back into container\n        render.container.addChild(render.spriteContainer);\n\n        // reset background state\n        render.currentBackground = null;\n\n        // reset bounds transforms\n        container.scale.set(1, 1);\n        container.position.set(0, 0);\n    };\n\n    /**\n     * Sets the background of the canvas \n     * @method setBackground\n     * @param {RenderPixi} render\n     * @param {string} background\n     * @deprecated\n     */\n    RenderPixi.setBackground = function(render, background) {\n        if (render.currentBackground !== background) {\n            var isColor = background.indexOf && background.indexOf('#') !== -1,\n                bgSprite = render.sprites['bg-0'];\n\n            if (isColor) {\n                // if solid background color\n                var color = Common.colorToNumber(background);\n                render.renderer.backgroundColor = color;\n\n                // remove background sprite if existing\n                if (bgSprite)\n                    render.container.removeChild(bgSprite); \n            } else {\n                // initialise background sprite if needed\n                if (!bgSprite) {\n                    var texture = _getTexture(render, background);\n\n                    bgSprite = render.sprites['bg-0'] = new PIXI.Sprite(texture);\n                    bgSprite.position.x = 0;\n                    bgSprite.position.y = 0;\n                    render.container.addChildAt(bgSprite, 0);\n                }\n            }\n\n            render.currentBackground = background;\n        }\n    };\n\n    /**\n     * Description\n     * @method world\n     * @param {engine} engine\n     * @deprecated\n     */\n    RenderPixi.world = function(render) {\n        var engine = render.engine,\n            world = engine.world,\n            renderer = render.renderer,\n            container = render.container,\n            options = render.options,\n            bodies = Composite.allBodies(world),\n            allConstraints = Composite.allConstraints(world),\n            constraints = [],\n            i;\n\n        if (options.wireframes) {\n            RenderPixi.setBackground(render, options.wireframeBackground);\n        } else {\n            RenderPixi.setBackground(render, options.background);\n        }\n\n        // handle bounds\n        var boundsWidth = render.bounds.max.x - render.bounds.min.x,\n            boundsHeight = render.bounds.max.y - render.bounds.min.y,\n            boundsScaleX = boundsWidth / render.options.width,\n            boundsScaleY = boundsHeight / render.options.height;\n\n        if (options.hasBounds) {\n            // Hide bodies that are not in view\n            for (i = 0; i < bodies.length; i++) {\n                var body = bodies[i];\n                body.render.sprite.visible = Bounds.overlaps(body.bounds, render.bounds);\n            }\n\n            // filter out constraints that are not in view\n            for (i = 0; i < allConstraints.length; i++) {\n                var constraint = allConstraints[i],\n                    bodyA = constraint.bodyA,\n                    bodyB = constraint.bodyB,\n                    pointAWorld = constraint.pointA,\n                    pointBWorld = constraint.pointB;\n\n                if (bodyA) pointAWorld = Vector.add(bodyA.position, constraint.pointA);\n                if (bodyB) pointBWorld = Vector.add(bodyB.position, constraint.pointB);\n\n                if (!pointAWorld || !pointBWorld)\n                    continue;\n\n                if (Bounds.contains(render.bounds, pointAWorld) || Bounds.contains(render.bounds, pointBWorld))\n                    constraints.push(constraint);\n            }\n\n            // transform the view\n            container.scale.set(1 / boundsScaleX, 1 / boundsScaleY);\n            container.position.set(-render.bounds.min.x * (1 / boundsScaleX), -render.bounds.min.y * (1 / boundsScaleY));\n        } else {\n            constraints = allConstraints;\n        }\n\n        for (i = 0; i < bodies.length; i++)\n            RenderPixi.body(render, bodies[i]);\n\n        for (i = 0; i < constraints.length; i++)\n            RenderPixi.constraint(render, constraints[i]);\n\n        renderer.render(container);\n    };\n\n\n    /**\n     * Description\n     * @method constraint\n     * @param {engine} engine\n     * @param {constraint} constraint\n     * @deprecated\n     */\n    RenderPixi.constraint = function(render, constraint) {\n        var engine = render.engine,\n            bodyA = constraint.bodyA,\n            bodyB = constraint.bodyB,\n            pointA = constraint.pointA,\n            pointB = constraint.pointB,\n            container = render.container,\n            constraintRender = constraint.render,\n            primitiveId = 'c-' + constraint.id,\n            primitive = render.primitives[primitiveId];\n\n        // initialise constraint primitive if not existing\n        if (!primitive)\n            primitive = render.primitives[primitiveId] = new PIXI.Graphics();\n\n        // don't render if constraint does not have two end points\n        if (!constraintRender.visible || !constraint.pointA || !constraint.pointB) {\n            primitive.clear();\n            return;\n        }\n\n        // add to scene graph if not already there\n        if (Common.indexOf(container.children, primitive) === -1)\n            container.addChild(primitive);\n\n        // render the constraint on every update, since they can change dynamically\n        primitive.clear();\n        primitive.beginFill(0, 0);\n        primitive.lineStyle(constraintRender.lineWidth, Common.colorToNumber(constraintRender.strokeStyle), 1);\n        \n        if (bodyA) {\n            primitive.moveTo(bodyA.position.x + pointA.x, bodyA.position.y + pointA.y);\n        } else {\n            primitive.moveTo(pointA.x, pointA.y);\n        }\n\n        if (bodyB) {\n            primitive.lineTo(bodyB.position.x + pointB.x, bodyB.position.y + pointB.y);\n        } else {\n            primitive.lineTo(pointB.x, pointB.y);\n        }\n\n        primitive.endFill();\n    };\n    \n    /**\n     * Description\n     * @method body\n     * @param {engine} engine\n     * @param {body} body\n     * @deprecated\n     */\n    RenderPixi.body = function(render, body) {\n        var engine = render.engine,\n            bodyRender = body.render;\n\n        if (!bodyRender.visible)\n            return;\n\n        if (bodyRender.sprite && bodyRender.sprite.texture) {\n            var spriteId = 'b-' + body.id,\n                sprite = render.sprites[spriteId],\n                spriteContainer = render.spriteContainer;\n\n            // initialise body sprite if not existing\n            if (!sprite)\n                sprite = render.sprites[spriteId] = _createBodySprite(render, body);\n\n            // add to scene graph if not already there\n            if (Common.indexOf(spriteContainer.children, sprite) === -1)\n                spriteContainer.addChild(sprite);\n\n            // update body sprite\n            sprite.position.x = body.position.x;\n            sprite.position.y = body.position.y;\n            sprite.rotation = body.angle;\n            sprite.scale.x = bodyRender.sprite.xScale || 1;\n            sprite.scale.y = bodyRender.sprite.yScale || 1;\n        } else {\n            var primitiveId = 'b-' + body.id,\n                primitive = render.primitives[primitiveId],\n                container = render.container;\n\n            // initialise body primitive if not existing\n            if (!primitive) {\n                primitive = render.primitives[primitiveId] = _createBodyPrimitive(render, body);\n                primitive.initialAngle = body.angle;\n            }\n\n            // add to scene graph if not already there\n            if (Common.indexOf(container.children, primitive) === -1)\n                container.addChild(primitive);\n\n            // update body primitive\n            primitive.position.x = body.position.x;\n            primitive.position.y = body.position.y;\n            primitive.rotation = body.angle - primitive.initialAngle;\n        }\n    };\n\n    /**\n     * Creates a body sprite\n     * @method _createBodySprite\n     * @private\n     * @param {RenderPixi} render\n     * @param {body} body\n     * @return {PIXI.Sprite} sprite\n     * @deprecated\n     */\n    var _createBodySprite = function(render, body) {\n        var bodyRender = body.render,\n            texturePath = bodyRender.sprite.texture,\n            texture = _getTexture(render, texturePath),\n            sprite = new PIXI.Sprite(texture);\n\n        sprite.anchor.x = body.render.sprite.xOffset;\n        sprite.anchor.y = body.render.sprite.yOffset;\n\n        return sprite;\n    };\n\n    /**\n     * Creates a body primitive\n     * @method _createBodyPrimitive\n     * @private\n     * @param {RenderPixi} render\n     * @param {body} body\n     * @return {PIXI.Graphics} graphics\n     * @deprecated\n     */\n    var _createBodyPrimitive = function(render, body) {\n        var bodyRender = body.render,\n            options = render.options,\n            primitive = new PIXI.Graphics(),\n            fillStyle = Common.colorToNumber(bodyRender.fillStyle),\n            strokeStyle = Common.colorToNumber(bodyRender.strokeStyle),\n            strokeStyleIndicator = Common.colorToNumber(bodyRender.strokeStyle),\n            strokeStyleWireframe = Common.colorToNumber('#bbb'),\n            strokeStyleWireframeIndicator = Common.colorToNumber('#CD5C5C'),\n            part;\n\n        primitive.clear();\n\n        // handle compound parts\n        for (var k = body.parts.length > 1 ? 1 : 0; k < body.parts.length; k++) {\n            part = body.parts[k];\n\n            if (!options.wireframes) {\n                primitive.beginFill(fillStyle, 1);\n                primitive.lineStyle(bodyRender.lineWidth, strokeStyle, 1);\n            } else {\n                primitive.beginFill(0, 0);\n                primitive.lineStyle(1, strokeStyleWireframe, 1);\n            }\n\n            primitive.moveTo(part.vertices[0].x - body.position.x, part.vertices[0].y - body.position.y);\n\n            for (var j = 1; j < part.vertices.length; j++) {\n                primitive.lineTo(part.vertices[j].x - body.position.x, part.vertices[j].y - body.position.y);\n            }\n\n            primitive.lineTo(part.vertices[0].x - body.position.x, part.vertices[0].y - body.position.y);\n\n            primitive.endFill();\n\n            // angle indicator\n            if (options.showAngleIndicator || options.showAxes) {\n                primitive.beginFill(0, 0);\n\n                if (options.wireframes) {\n                    primitive.lineStyle(1, strokeStyleWireframeIndicator, 1);\n                } else {\n                    primitive.lineStyle(1, strokeStyleIndicator);\n                }\n\n                primitive.moveTo(part.position.x - body.position.x, part.position.y - body.position.y);\n                primitive.lineTo(((part.vertices[0].x + part.vertices[part.vertices.length-1].x) / 2 - body.position.x), \n                                 ((part.vertices[0].y + part.vertices[part.vertices.length-1].y) / 2 - body.position.y));\n\n                primitive.endFill();\n            }\n        }\n\n        return primitive;\n    };\n\n    /**\n     * Gets the requested texture (a PIXI.Texture) via its path\n     * @method _getTexture\n     * @private\n     * @param {RenderPixi} render\n     * @param {string} imagePath\n     * @return {PIXI.Texture} texture\n     * @deprecated\n     */\n    var _getTexture = function(render, imagePath) {\n        var texture = render.textures[imagePath];\n\n        if (!texture)\n            texture = render.textures[imagePath] = PIXI.Texture.fromImage(imagePath);\n\n        return texture;\n    };\n\n})();\n\n},{\"../body/Composite\":2,\"../core/Common\":14,\"../core/Events\":16,\"../geometry/Bounds\":26,\"../geometry/Vector\":28}]},{},[30])(30)\n});\n\n\n// WEBPACK FOOTER //\n// ./node_modules/matter-js/build/matter.js","// removed by extract-text-webpack-plugin\nmodule.exports = {\"trash\":\"dh-dh-plastic-counter-trash\",\"trash__fallback\":\"dh-dh-plastic-counter-trash__fallback\",\"trash--active\":\"dh-dh-plastic-counter-trash--active\",\"trash__fallback-top\":\"dh-dh-plastic-counter-trash__fallback-top\",\"trash__fallback-body\":\"dh-dh-plastic-counter-trash__fallback-body\"};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./src/v1/components/Trash.css\n// module id = 28\n// module chunks = 0","// @flow @jsx h\n\nimport { h, Component } from 'preact'\nimport styles from './Sea.css'\n\nexport class Sea extends Component<{}, {}> {\n  shouldComponentUpdate () {\n    return false\n  }\n  render () {\n    return (\n      <div class={styles.sea}>\n        <div class={styles.sea__waves} />\n      </div>\n    )\n  }\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/v1/components/Sea.js","// removed by extract-text-webpack-plugin\nmodule.exports = {\"sea\":\"dh-dh-plastic-counter-sea\",\"sea__waves\":\"dh-dh-plastic-counter-sea__waves\",\"app--small\":\"dh-dh-plastic-counter-app--small\",\"app--medium\":\"dh-dh-plastic-counter-app--medium\",\"app--large\":\"dh-dh-plastic-counter-app--large\",\"app--extra-large\":\"dh-dh-plastic-counter-app--extra-large\",\"app--has-intersected\":\"dh-dh-plastic-counter-app--has-intersected\",\"move\":\"dh-dh-plastic-counter-move\",\"sea__flowers\":\"dh-dh-plastic-counter-sea__flowers\"};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./src/v1/components/Sea.css\n// module id = 30\n// module chunks = 0","// @flow @jsx h\n\nimport { h, Component } from 'preact'\nimport styles from './SeaOverlay.css'\n\nexport class SeaOverlay extends Component<{}, {}> {\n  shouldComponentUpdate () {\n    return false\n  }\n  render () {\n    return <div class={styles['sea-overlay']} />\n  }\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/v1/components/SeaOverlay.js","// removed by extract-text-webpack-plugin\nmodule.exports = {\"sea-overlay\":\"dh-dh-plastic-counter-sea-overlay\"};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./src/v1/components/SeaOverlay.css\n// module id = 32\n// module chunks = 0","// @flow @jsx h\n\nimport { h, Component } from 'preact'\nimport styles from './SeaLight.css'\n\nexport class SeaLight extends Component<{}, {}> {\n  shouldComponentUpdate () {\n    return false\n  }\n  render () {\n    return <div class={styles['sea-light']} />\n  }\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/v1/components/SeaLight.js","// removed by extract-text-webpack-plugin\nmodule.exports = {\"sea-light\":\"dh-dh-plastic-counter-sea-light\"};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./src/v1/components/SeaLight.css\n// module id = 34\n// module chunks = 0","!function(e,n){\"object\"==typeof exports&&\"undefined\"!=typeof module?n(exports):\"function\"==typeof define&&define.amd?define([\"exports\"],n):n(e[\"dh-analytics-utils\"]={})}(this,function(e){\"use strict\";function n(){return window.ga}var t=Object.assign||function(e){for(var n=1;n<arguments.length;n++){var t=arguments[n];for(var o in t)Object.prototype.hasOwnProperty.call(t,o)&&(e[o]=t[o])}return e};e.createGoogleAnalyticsTracker=function(e){var o=[],r=e.name,a=e.gaPropertyId,i=e.self,l=e.context;if(!(r&&a&&i&&l))throw new Error(\"Unable to create google analytics tracker. Please pass an object containing name, gaPropertyId, self and context to createGoogleAnalyticsTracker method\");var c,s,d,u,f,g,p,y,w=(c=i.id,s=l.id,d=i.title,u=i.publishedDate,f=c===s,g=document.referrer,{dimension1:c?\"pp:\"+c:null,dimension2:d||null,dimension3:u?String(u.getFullYear()):null,dimension4:u?String(u.getMonth()+1):null,dimension5:u?String(u.getDate()):null,dimension6:g.replace(/^(https?:\\/\\/)?www./,\"$1\"),dimension7:g.replace(/^(https?:\\/\\/)/,\"\").replace(/^www./,\"\"),dimension10:f?null:s?\"pp:\"+s:null}),v=(p=o,y=!1,function(e,o,r,a,i){if(!r.category||!r.action)throw new Error(\"Error sending event to google analytics: Event is missing mandatory fields category and/or action\");n()?(y||(function(e,n){window.ga(\"create\",{trackingId:n,cookieDomain:\"auto\",name:e}),window.ga(e+\".set\",\"anonymizeIp\",!0)}(e,o),y=!0),window.ga(e+\".send\",\"event\",function(e,n){var o={};e.hasOwnProperty(\"category\")&&(o.eventCategory=e.category),e.hasOwnProperty(\"action\")&&(o.eventAction=e.action),e.hasOwnProperty(\"label\")&&(o.eventLabel=e.label),e.hasOwnProperty(\"value\")&&(o.eventValue=e.value),o.nonInteraction=e.nonInteraction||!1;var r=t({},n,e.fieldsObject);return t({},o,r)}(r,a))):p.push(r)}),m=setInterval(function(){if(n())for(clearInterval(m);o.length;){var e=o.shift();v(r,a,e,w)}},1e3);return{sendEvent:function(e){v(r,a,e,w)}}},Object.defineProperty(e,\"__esModule\",{value:!0})});\n\n\n\n// WEBPACK FOOTER //\n// ./node_modules/@nrk/dh-analytics-utils/dist/dh-analytics-utils.min.js","// @flow\n\nconst POLOPOLY_ID_REGEX = /[1-9]{1,2}\\.\\d+/g\n\nexport function getContextId (url: string): ?string {\n  return extractPolopolyIdFromString(url)\n}\n\nfunction extractPolopolyIdFromString (str: string): ?string {\n  const matches = str.match(POLOPOLY_ID_REGEX)\n  if (matches && matches.length) {\n    return matches[0]\n  }\n  return null\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/lib/getContextId.js"],"sourceRoot":""}