{"version":3,"file":"static/js/46.a1a477e1.chunk.js","mappings":"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","sources":["../node_modules/matter-js/build/matter.js","../node_modules/src/observe.ts","../node_modules/src/InView.tsx","../node_modules/src/useInView.tsx"],"sourcesContent":["/*!\n * matter-js 0.18.0 by @liabru\n * http://brm.io/matter-js/\n * License MIT\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(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory();\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine(\"Matter\", [], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"Matter\"] = factory();\n\telse\n\t\troot[\"Matter\"] = factory();\n})(this, function() {\nreturn /******/ (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, { enumerable: true, get: getter });\n/******/ \t\t}\n/******/ \t};\n/******/\n/******/ \t// define __esModule on exports\n/******/ \t__webpack_require__.r = function(exports) {\n/******/ \t\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n/******/ \t\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n/******/ \t\t}\n/******/ \t\tObject.defineProperty(exports, '__esModule', { value: true });\n/******/ \t};\n/******/\n/******/ \t// create a fake namespace object\n/******/ \t// mode & 1: value is a module id, require it\n/******/ \t// mode & 2: merge all properties of value into the ns\n/******/ \t// mode & 4: return value when already ns object\n/******/ \t// mode & 8|1: behave like require\n/******/ \t__webpack_require__.t = function(value, mode) {\n/******/ \t\tif(mode & 1) value = __webpack_require__(value);\n/******/ \t\tif(mode & 8) return value;\n/******/ \t\tif((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;\n/******/ \t\tvar ns = Object.create(null);\n/******/ \t\t__webpack_require__.r(ns);\n/******/ \t\tObject.defineProperty(ns, 'default', { enumerable: true, value: value });\n/******/ \t\tif(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));\n/******/ \t\treturn ns;\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 = \"\";\n/******/\n/******/\n/******/ \t// Load entry module and return exports\n/******/ \treturn __webpack_require__(__webpack_require__.s = 21);\n/******/ })\n/************************************************************************/\n/******/ ([\n/* 0 */\n/***/ (function(module, exports) {\n\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    Common._warnedOnce = {};\n    Common._decomp = null;\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 is in milliseconds and will use high-resolution timing if available.\n     * @method now\n     * @return {number} the current timestamp in milliseconds\n     */\n    Common.now = function() {\n        if (typeof window !== 'undefined' && 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        if (Date.now) {\n            return Date.now();\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     * Uses `Common.warn` to log the given message one time only.\n     * @method warnOnce\n     * @param ...objs {} The objects to log.\n     */\n    Common.warnOnce = function() {\n        var message = Array.prototype.slice.call(arguments).join(' ');\n\n        if (!Common._warnedOnce[message]) {\n            Common.warn(message);\n            Common._warnedOnce[message] = true;\n        }\n    };\n\n    /**\n     * Shows a deprecated console warning when the function on the given object is called.\n     * The target function will be replaced with a new function that first shows the warning\n     * and then calls the original function.\n     * @method deprecated\n     * @param {object} obj The object or module\n     * @param {string} name The property name of the function on obj\n     * @param {string} warning The one-time message to show if the function is called\n     */\n    Common.deprecated = function(obj, prop, warning) {\n        obj[prop] = Common.chain(function() {\n            Common.warnOnce('🔅 deprecated 🔅', warning);\n        }, obj[prop]);\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     * Provide the [poly-decomp](https://github.com/schteppe/poly-decomp.js) library module to enable\n     * concave vertex decomposition support when using `Bodies.fromVertices` e.g. `Common.setDecomp(require('poly-decomp'))`.\n     * @method setDecomp\n     * @param {} decomp The [poly-decomp](https://github.com/schteppe/poly-decomp.js) library module.\n     */\n    Common.setDecomp = function(decomp) {\n        Common._decomp = decomp;\n    };\n\n    /**\n     * Returns the [poly-decomp](https://github.com/schteppe/poly-decomp.js) library module provided through `Common.setDecomp`,\n     * otherwise returns the global `decomp` if set.\n     * @method getDecomp\n     * @return {} The [poly-decomp](https://github.com/schteppe/poly-decomp.js) library module if provided.\n     */\n    Common.getDecomp = function() {\n        // get user provided decomp if set\n        var decomp = Common._decomp;\n\n        try {\n            // otherwise from window global\n            if (!decomp && typeof window !== 'undefined') {\n                decomp = window.decomp;\n            }\n    \n            // otherwise from node global\n            if (!decomp && typeof global !== 'undefined') {\n                decomp = global.decomp;\n            }\n        } catch (e) {\n            // decomp not available\n            decomp = null;\n        }\n\n        return decomp;\n    };\n})();\n\n\n/***/ }),\n/* 1 */\n/***/ (function(module, exports) {\n\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\n/***/ }),\n/* 2 */\n/***/ (function(module, exports) {\n\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 between the vector `vectorB - vectorA` and the x-axis in radians.\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\n/***/ }),\n/* 3 */\n/***/ (function(module, exports, __webpack_require__) {\n\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 = __webpack_require__(2);\nvar Common = __webpack_require__(0);\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        scalar = typeof scalar !== 'undefined' ? scalar : 1;\n\n        var verticesLength = vertices.length,\n            translateX = vector.x * scalar,\n            translateY = vector.y * scalar,\n            i;\n        \n        for (i = 0; i < verticesLength; i++) {\n            vertices[i].x += translateX;\n            vertices[i].y += translateY;\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            pointX = point.x,\n            pointY = point.y,\n            verticesLength = vertices.length,\n            vertex,\n            dx,\n            dy,\n            i;\n\n        for (i = 0; i < verticesLength; i++) {\n            vertex = vertices[i];\n            dx = vertex.x - pointX;\n            dy = vertex.y - pointY;\n            vertex.x = pointX + (dx * cos - dy * sin);\n            vertex.y = pointY + (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        var pointX = point.x,\n            pointY = point.y,\n            verticesLength = vertices.length,\n            vertex = vertices[verticesLength - 1],\n            nextVertex;\n\n        for (var i = 0; i < verticesLength; i++) {\n            nextVertex = vertices[i];\n\n            if ((pointX - vertex.x) * (nextVertex.y - vertex.y) \n                + (pointY - vertex.y) * (vertex.x - nextVertex.x) > 0) {\n                return false;\n            }\n\n            vertex = nextVertex;\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\n/***/ }),\n/* 4 */\n/***/ (function(module, exports, __webpack_require__) {\n\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 = __webpack_require__(0);\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        var events = object.events;\n        \n        if (events && Common.keys(events).length > 0) {\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 = 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\n/***/ }),\n/* 5 */\n/***/ (function(module, exports, __webpack_require__) {\n\n/**\n* A composite is a collection of `Matter.Body`, `Matter.Constraint` and other `Matter.Composite` objects.\n*\n* They are a container that can represent complex objects made of multiple parts, even if they are not physically connected.\n* A composite could contain anything from a single body all the way up to a whole world.\n* \n* When making any changes to composites, use the included functions rather than changing their properties directly.\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 = __webpack_require__(4);\nvar Common = __webpack_require__(0);\nvar Bounds = __webpack_require__(1);\nvar Body = __webpack_require__(6);\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            cache: {\n                allBodies: null,\n                allConstraints: null,\n                allComposites: null\n            }\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     * @private\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 (isModified && composite.cache) {\n            composite.cache.allBodies = null;\n            composite.cache.allConstraints = null;\n            composite.cache.allComposites = null;\n        }\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 single or multi-add function. Adds a single or an array of body(s), constraint(s) or 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|array} object A single or an array of body(s), constraint(s) or composite(s)\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|array} 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        }\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        }\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\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        if (composite.cache && composite.cache.allBodies) {\n            return composite.cache.allBodies;\n        }\n\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        if (composite.cache) {\n            composite.cache.allBodies = bodies;\n        }\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        if (composite.cache && composite.cache.allConstraints) {\n            return composite.cache.allConstraints;\n        }\n\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        if (composite.cache) {\n            composite.cache.allConstraints = constraints;\n        }\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        if (composite.cache && composite.cache.allComposites) {\n            return composite.cache.allComposites;\n        }\n\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        if (composite.cache) {\n            composite.cache.allComposites = composites;\n        }\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        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        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        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        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 = 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 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     * This is automatically managed when bodies, constraints or composites are added or removed.\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     * An object used for storing cached results for performance reasons.\n     * This is used internally only and is automatically managed.\n     *\n     * @private\n     * @property cache\n     * @type {}\n     */\n\n})();\n\n\n/***/ }),\n/* 6 */\n/***/ (function(module, exports, __webpack_require__) {\n\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 = __webpack_require__(3);\nvar Vector = __webpack_require__(2);\nvar Sleeping = __webpack_require__(7);\nvar Render = __webpack_require__(16);\nvar Common = __webpack_require__(0);\nvar Bounds = __webpack_require__(1);\nvar Axes = __webpack_require__(11);\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                strokeStyle: null,\n                fillStyle: null,\n                lineWidth: null,\n                sprite: {\n                    xScale: 1,\n                    yScale: 1,\n                    xOffset: 0,\n                    yOffset: 0\n                }\n            },\n            events: null,\n            bounds: null,\n            chamfer: null,\n            circleRadius: 0,\n            positionPrev: null,\n            anglePrev: 0,\n            parent: null,\n            axes: null,\n            area: 0,\n            mass: 0,\n            inertia: 0,\n            _original: null\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 ? '#14151f' : Common.choose(['#f19648', '#f5d259', '#f55a3c', '#063e7b', '#ececd1'])),\n            defaultStrokeStyle = body.isStatic ? '#555' : '#ccc',\n            defaultLineWidth = body.isStatic && body.render.fillStyle === null ? 1 : 0;\n        body.render.fillStyle = body.render.fillStyle || defaultFillStyle;\n        body.render.strokeStyle = body.render.strokeStyle || defaultStrokeStyle;\n        body.render.lineWidth = body.render.lineWidth || defaultLineWidth;\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            if (!Object.prototype.hasOwnProperty.call(settings, property))\n                continue;\n\n            value = settings[property];\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            case 'centre':\n                Body.setCentre(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                part._original = null;\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. \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     * Set the centre of mass of the body. \n     * The `centre` is a vector in world-space unless `relative` is set, in which case it is a translation.\n     * The centre of mass is the point the body rotates about and can be used to simulate non-uniform density.\n     * This is equal to moving `body.position` but not the `body.vertices`.\n     * Invalid if the `centre` falls outside the body's convex hull.\n     * @method setCentre\n     * @param {body} body\n     * @param {vector} centre\n     * @param {bool} relative\n     */\n    Body.setCentre = function(body, centre, relative) {\n        if (!relative) {\n            body.positionPrev.x = centre.x - (body.position.x - body.positionPrev.x);\n            body.positionPrev.y = centre.y - (body.position.y - body.positionPrev.y);\n            body.position.x = centre.x;\n            body.position.y = centre.y;\n        } else {\n            body.positionPrev.x += centre.x;\n            body.positionPrev.y += centre.y;\n            body.position.x += centre.x;\n            body.position.y += centre.y;\n        }\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\n/***/ }),\n/* 7 */\n/***/ (function(module, exports, __webpack_require__) {\n\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 = __webpack_require__(4);\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\n/***/ }),\n/* 8 */\n/***/ (function(module, exports, __webpack_require__) {\n\n/**\n* The `Matter.Collision` module contains methods for detecting collisions between a given pair of bodies.\n*\n* For efficient detection between a list of bodies, see `Matter.Detector` and `Matter.Query`.\n*\n* See `Matter.Engine` for collision events.\n*\n* @class Collision\n*/\n\nvar Collision = {};\n\nmodule.exports = Collision;\n\nvar Vertices = __webpack_require__(3);\nvar Pair = __webpack_require__(9);\n\n(function() {\n    var _supports = [];\n\n    var _overlapAB = {\n        overlap: 0,\n        axis: null\n    };\n\n    var _overlapBA = {\n        overlap: 0,\n        axis: null\n    };\n\n    /**\n     * Creates a new collision record.\n     * @method create\n     * @param {body} bodyA The first body part represented by the collision record\n     * @param {body} bodyB The second body part represented by the collision record\n     * @return {collision} A new collision record\n     */\n    Collision.create = function(bodyA, bodyB) {\n        return { \n            pair: null,\n            collided: false,\n            bodyA: bodyA,\n            bodyB: bodyB,\n            parentA: bodyA.parent,\n            parentB: bodyB.parent,\n            depth: 0,\n            normal: { x: 0, y: 0 },\n            tangent: { x: 0, y: 0 },\n            penetration: { x: 0, y: 0 },\n            supports: []\n        };\n    };\n\n    /**\n     * Detect collision between two bodies.\n     * @method collides\n     * @param {body} bodyA\n     * @param {body} bodyB\n     * @param {pairs} [pairs] Optionally reuse collision records from existing pairs.\n     * @return {collision|null} A collision record if detected, otherwise null\n     */\n    Collision.collides = function(bodyA, bodyB, pairs) {\n        Collision._overlapAxes(_overlapAB, bodyA.vertices, bodyB.vertices, bodyA.axes);\n\n        if (_overlapAB.overlap <= 0) {\n            return null;\n        }\n\n        Collision._overlapAxes(_overlapBA, bodyB.vertices, bodyA.vertices, bodyB.axes);\n\n        if (_overlapBA.overlap <= 0) {\n            return null;\n        }\n\n        // reuse collision records for gc efficiency\n        var pair = pairs && pairs.table[Pair.id(bodyA, bodyB)],\n            collision;\n\n        if (!pair) {\n            collision = Collision.create(bodyA, bodyB);\n            collision.collided = true;\n            collision.bodyA = bodyA.id < bodyB.id ? bodyA : bodyB;\n            collision.bodyB = bodyA.id < bodyB.id ? bodyB : bodyA;\n            collision.parentA = collision.bodyA.parent;\n            collision.parentB = collision.bodyB.parent;\n        } else {\n            collision = pair.collision;\n        }\n\n        bodyA = collision.bodyA;\n        bodyB = collision.bodyB;\n\n        var minOverlap;\n\n        if (_overlapAB.overlap < _overlapBA.overlap) {\n            minOverlap = _overlapAB;\n        } else {\n            minOverlap = _overlapBA;\n        }\n\n        var normal = collision.normal,\n            supports = collision.supports,\n            minAxis = minOverlap.axis,\n            minAxisX = minAxis.x,\n            minAxisY = minAxis.y;\n\n        // ensure normal is facing away from bodyA\n        if (minAxisX * (bodyB.position.x - bodyA.position.x) + minAxisY * (bodyB.position.y - bodyA.position.y) < 0) {\n            normal.x = minAxisX;\n            normal.y = minAxisY;\n        } else {\n            normal.x = -minAxisX;\n            normal.y = -minAxisY;\n        }\n        \n        collision.tangent.x = -normal.y;\n        collision.tangent.y = normal.x;\n\n        collision.depth = minOverlap.overlap;\n\n        collision.penetration.x = normal.x * collision.depth;\n        collision.penetration.y = normal.y * collision.depth;\n\n        // find support points, there is always either exactly one or two\n        var supportsB = Collision._findSupports(bodyA, bodyB, normal, 1),\n            supportCount = 0;\n\n        // find the supports from bodyB that are inside bodyA\n        if (Vertices.contains(bodyA.vertices, supportsB[0])) {\n            supports[supportCount++] = supportsB[0];\n        }\n\n        if (Vertices.contains(bodyA.vertices, supportsB[1])) {\n            supports[supportCount++] = supportsB[1];\n        }\n\n        // find the supports from bodyA that are inside bodyB\n        if (supportCount < 2) {\n            var supportsA = Collision._findSupports(bodyB, bodyA, normal, -1);\n\n            if (Vertices.contains(bodyB.vertices, supportsA[0])) {\n                supports[supportCount++] = supportsA[0];\n            }\n\n            if (supportCount < 2 && Vertices.contains(bodyB.vertices, supportsA[1])) {\n                supports[supportCount++] = supportsA[1];\n            }\n        }\n\n        // account for the edge case of overlapping but no vertex containment\n        if (supportCount === 0) {\n            supports[supportCount++] = supportsB[0];\n        }\n\n        // update supports array size\n        supports.length = supportCount;\n\n        return collision;\n    };\n\n    /**\n     * Find the overlap between two sets of vertices.\n     * @method _overlapAxes\n     * @private\n     * @param {object} result\n     * @param {vertices} verticesA\n     * @param {vertices} verticesB\n     * @param {axes} axes\n     */\n    Collision._overlapAxes = function(result, verticesA, verticesB, axes) {\n        var verticesALength = verticesA.length,\n            verticesBLength = verticesB.length,\n            verticesAX = verticesA[0].x,\n            verticesAY = verticesA[0].y,\n            verticesBX = verticesB[0].x,\n            verticesBY = verticesB[0].y,\n            axesLength = axes.length,\n            overlapMin = Number.MAX_VALUE,\n            overlapAxisNumber = 0,\n            overlap,\n            overlapAB,\n            overlapBA,\n            dot,\n            i,\n            j;\n\n        for (i = 0; i < axesLength; i++) {\n            var axis = axes[i],\n                axisX = axis.x,\n                axisY = axis.y,\n                minA = verticesAX * axisX + verticesAY * axisY,\n                minB = verticesBX * axisX + verticesBY * axisY,\n                maxA = minA,\n                maxB = minB;\n            \n            for (j = 1; j < verticesALength; j += 1) {\n                dot = verticesA[j].x * axisX + verticesA[j].y * axisY;\n\n                if (dot > maxA) { \n                    maxA = dot;\n                } else if (dot < minA) { \n                    minA = dot;\n                }\n            }\n\n            for (j = 1; j < verticesBLength; j += 1) {\n                dot = verticesB[j].x * axisX + verticesB[j].y * axisY;\n\n                if (dot > maxB) { \n                    maxB = dot;\n                } else if (dot < minB) { \n                    minB = dot;\n                }\n            }\n\n            overlapAB = maxA - minB;\n            overlapBA = maxB - minA;\n            overlap = overlapAB < overlapBA ? overlapAB : overlapBA;\n\n            if (overlap < overlapMin) {\n                overlapMin = overlap;\n                overlapAxisNumber = i;\n\n                if (overlap <= 0) {\n                    // can not be intersecting\n                    break;\n                }\n            } \n        }\n\n        result.axis = axes[overlapAxisNumber];\n        result.overlap = overlapMin;\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    Collision._projectToAxis = function(projection, vertices, axis) {\n        var min = vertices[0].x * axis.x + vertices[0].y * axis.y,\n            max = min;\n\n        for (var i = 1; i < vertices.length; i += 1) {\n            var dot = vertices[i].x * axis.x + vertices[i].y * axis.y;\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 {body} bodyA\n     * @param {body} bodyB\n     * @param {vector} normal\n     * @param {number} direction\n     * @return [vector]\n     */\n    Collision._findSupports = function(bodyA, bodyB, normal, direction) {\n        var vertices = bodyB.vertices,\n            verticesLength = vertices.length,\n            bodyAPositionX = bodyA.position.x,\n            bodyAPositionY = bodyA.position.y,\n            normalX = normal.x * direction,\n            normalY = normal.y * direction,\n            nearestDistance = Number.MAX_VALUE,\n            vertexA,\n            vertexB,\n            vertexC,\n            distance,\n            j;\n\n        // find deepest vertex relative to the axis\n        for (j = 0; j < verticesLength; j += 1) {\n            vertexB = vertices[j];\n            distance = normalX * (bodyAPositionX - vertexB.x) + normalY * (bodyAPositionY - vertexB.y);\n\n            // convex hill-climbing\n            if (distance < nearestDistance) {\n                nearestDistance = distance;\n                vertexA = vertexB;\n            }\n        }\n\n        // measure next vertex\n        vertexC = vertices[(verticesLength + vertexA.index - 1) % verticesLength];\n        nearestDistance = normalX * (bodyAPositionX - vertexC.x) + normalY * (bodyAPositionY - vertexC.y);\n\n        // compare with previous vertex\n        vertexB = vertices[(vertexA.index + 1) % verticesLength];\n        if (normalX * (bodyAPositionX - vertexB.x) + normalY * (bodyAPositionY - vertexB.y) < nearestDistance) {\n            _supports[0] = vertexA;\n            _supports[1] = vertexB;\n\n            return _supports;\n        }\n\n        _supports[0] = vertexA;\n        _supports[1] = vertexC;\n\n        return _supports;\n    };\n\n    /*\n    *\n    *  Properties Documentation\n    *\n    */\n\n    /**\n     * A reference to the pair using this collision record, if there is one.\n     *\n     * @property pair\n     * @type {pair|null}\n     * @default null\n     */\n\n    /**\n     * A flag that indicates if the bodies were colliding when the collision was last updated.\n     * \n     * @property collided\n     * @type boolean\n     * @default false\n     */\n\n    /**\n     * The first body part represented by the collision (see also `collision.parentA`).\n     * \n     * @property bodyA\n     * @type body\n     */\n\n    /**\n     * The second body part represented by the collision (see also `collision.parentB`).\n     * \n     * @property bodyB\n     * @type body\n     */\n\n    /**\n     * The first body represented by the collision (i.e. `collision.bodyA.parent`).\n     * \n     * @property parentA\n     * @type body\n     */\n\n    /**\n     * The second body represented by the collision (i.e. `collision.bodyB.parent`).\n     * \n     * @property parentB\n     * @type body\n     */\n\n    /**\n     * A `Number` that represents the minimum separating distance between the bodies along the collision normal.\n     *\n     * @readOnly\n     * @property depth\n     * @type number\n     * @default 0\n     */\n\n    /**\n     * A normalised `Vector` that represents the direction between the bodies that provides the minimum separating distance.\n     *\n     * @property normal\n     * @type vector\n     * @default { x: 0, y: 0 }\n     */\n\n    /**\n     * A normalised `Vector` that is the tangent direction to the collision normal.\n     *\n     * @property tangent\n     * @type vector\n     * @default { x: 0, y: 0 }\n     */\n\n    /**\n     * A `Vector` that represents the direction and depth of the collision.\n     *\n     * @property penetration\n     * @type vector\n     * @default { x: 0, y: 0 }\n     */\n\n    /**\n     * An array of body vertices that represent the support points in the collision.\n     * These are the deepest vertices (along the collision normal) of each body that are contained by the other body's vertices.\n     *\n     * @property supports\n     * @type vector[]\n     * @default []\n     */\n\n})();\n\n\n/***/ }),\n/* 9 */\n/***/ (function(module, exports, __webpack_require__) {\n\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 = __webpack_require__(17);\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\n        var pair = {\n            id: Pair.id(bodyA, bodyB),\n            bodyA: bodyA,\n            bodyB: bodyB,\n            collision: collision,\n            contacts: [],\n            activeContacts: [],\n            separation: 0,\n            isActive: true,\n            confirmedActive: true,\n            isSensor: bodyA.isSensor || bodyB.isSensor,\n            timeCreated: timestamp,\n            timeUpdated: timestamp,\n            inverseMass: 0,\n            friction: 0,\n            frictionStatic: 0,\n            restitution: 0,\n            slop: 0\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            parentAVerticesLength = parentA.vertices.length;\n        \n        pair.isActive = true;\n        pair.timeUpdated = timestamp;\n        pair.collision = collision;\n        pair.separation = collision.depth;\n        pair.inverseMass = parentA.inverseMass + parentB.inverseMass;\n        pair.friction = parentA.friction < parentB.friction ? parentA.friction : parentB.friction;\n        pair.frictionStatic = parentA.frictionStatic > parentB.frictionStatic ? parentA.frictionStatic : parentB.frictionStatic;\n        pair.restitution = parentA.restitution > parentB.restitution ? parentA.restitution : parentB.restitution;\n        pair.slop = parentA.slop > parentB.slop ? parentA.slop : parentB.slop;\n\n        collision.pair = pair;\n        activeContacts.length = 0;\n        \n        for (var i = 0; i < supports.length; i++) {\n            var support = supports[i],\n                contactId = support.body === parentA ? support.index : parentAVerticesLength + support.index,\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    \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\n/***/ }),\n/* 10 */\n/***/ (function(module, exports, __webpack_require__) {\n\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 = __webpack_require__(3);\nvar Vector = __webpack_require__(2);\nvar Sleeping = __webpack_require__(7);\nvar Bounds = __webpack_require__(1);\nvar Axes = __webpack_require__(11);\nvar Common = __webpack_require__(0);\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     * Returns the world-space position of `constraint.pointA`, accounting for `constraint.bodyA`.\n     * @method pointAWorld\n     * @param {constraint} constraint\n     * @returns {vector} the world-space position\n     */\n    Constraint.pointAWorld = function(constraint) {\n        return {\n            x: (constraint.bodyA ? constraint.bodyA.position.x : 0) + constraint.pointA.x,\n            y: (constraint.bodyA ? constraint.bodyA.position.y : 0) + constraint.pointA.y\n        };\n    };\n\n    /**\n     * Returns the world-space position of `constraint.pointB`, accounting for `constraint.bodyB`.\n     * @method pointBWorld\n     * @param {constraint} constraint\n     * @returns {vector} the world-space position\n     */\n    Constraint.pointBWorld = function(constraint) {\n        return {\n            x: (constraint.bodyB ? constraint.bodyB.position.x : 0) + constraint.pointB.x,\n            y: (constraint.bodyB ? constraint.bodyB.position.y : 0) + constraint.pointB.y\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.bodyB` 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\n/***/ }),\n/* 11 */\n/***/ (function(module, exports, __webpack_require__) {\n\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 = __webpack_require__(2);\nvar Common = __webpack_require__(0);\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\n/***/ }),\n/* 12 */\n/***/ (function(module, exports, __webpack_require__) {\n\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 = __webpack_require__(3);\nvar Common = __webpack_require__(0);\nvar Body = __webpack_require__(6);\nvar Bounds = __webpack_require__(1);\nvar Vector = __webpack_require__(2);\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     * Utility to create a compound body based on set(s) of vertices.\n     * \n     * _Note:_ To optionally enable automatic concave vertices decomposition the [poly-decomp](https://github.com/schteppe/poly-decomp.js) \n     * package must be first installed and provided see `Common.setDecomp`, otherwise the convex hull of each vertex set will be used.\n     * \n     * The resulting vertices are reorientated about their centre of mass,\n     * and offset such that `body.position` corresponds to this point.\n     * \n     * The resulting offset may be found if needed by subtracting `body.bounds` from the original input bounds.\n     * To later move the centre of mass see `Body.setCentre`.\n     * \n     * Note that automatic conconcave decomposition results are not always optimal. \n     * For best results, simplify the input vertices as much as possible first.\n     * By default this function applies some addtional simplification to help.\n     * \n     * Some outputs may also require further manual processing afterwards to be robust.\n     * In particular some parts may need to be overlapped to avoid collision gaps.\n     * Thin parts and sharp points should be avoided or removed where possible.\n     *\n     * The options parameter object specifies any `Matter.Body` properties you wish to override the defaults.\n     * \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 {array} vertexSets One or more arrays of vertex points e.g. `[[{ x: 0, y: 0 }...], ...]`.\n     * @param {object} [options] The body options.\n     * @param {bool} [flagInternal=false] Optionally marks internal edges with `isInternal`.\n     * @param {number} [removeCollinear=0.01] Threshold when simplifying vertices along the same edge.\n     * @param {number} [minimumArea=10] Threshold when removing small parts.\n     * @param {number} [removeDuplicatePoints=0.01] Threshold when simplifying nearby vertices.\n     * @return {body}\n     */\n    Bodies.fromVertices = function(x, y, vertexSets, options, flagInternal, removeCollinear, minimumArea, removeDuplicatePoints) {\n        var decomp = Common.getDecomp(),\n            canDecomp,\n            body,\n            parts,\n            isConvex,\n            isConcave,\n            vertices,\n            i,\n            j,\n            k,\n            v,\n            z;\n\n        // check decomp is as expected\n        canDecomp = Boolean(decomp && decomp.quickDecomp);\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        removeDuplicatePoints = typeof removeDuplicatePoints !== 'undefined' ? removeDuplicatePoints : 0.01;\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            isConcave = !isConvex;\n\n            if (isConcave && !canDecomp) {\n                Common.warnOnce(\n                    'Bodies.fromVertices: Install the \\'poly-decomp\\' library and use Common.setDecomp or provide \\'decomp\\' as a global to decompose concave vertices.'\n                );\n            }\n\n            if (isConvex || !canDecomp) {\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                if (removeDuplicatePoints !== false && decomp.removeDuplicatePoints)\n                    decomp.removeDuplicatePoints(concave, removeDuplicatePoints);\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\n            // offset such that body.position is at the centre off mass\n            Body.setPosition(body, { x: x, y: y });\n\n            return body;\n        } else {\n            return parts[0];\n        }\n    };\n\n})();\n\n\n/***/ }),\n/* 13 */\n/***/ (function(module, exports, __webpack_require__) {\n\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 = __webpack_require__(0);\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 = parseInt(mouse.element.getAttribute('data-pixel-ratio'), 10) || 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\n/***/ }),\n/* 14 */\n/***/ (function(module, exports, __webpack_require__) {\n\n/**\n* The `Matter.Detector` module contains methods for efficiently detecting collisions between a list of bodies using a broadphase algorithm.\n*\n* @class Detector\n*/\n\nvar Detector = {};\n\nmodule.exports = Detector;\n\nvar Common = __webpack_require__(0);\nvar Collision = __webpack_require__(8);\n\n(function() {\n\n    /**\n     * Creates a new collision detector.\n     * @method create\n     * @param {} options\n     * @return {detector} A new collision detector\n     */\n    Detector.create = function(options) {\n        var defaults = {\n            bodies: [],\n            pairs: null\n        };\n\n        return Common.extend(defaults, options);\n    };\n\n    /**\n     * Sets the list of bodies in the detector.\n     * @method setBodies\n     * @param {detector} detector\n     * @param {body[]} bodies\n     */\n    Detector.setBodies = function(detector, bodies) {\n        detector.bodies = bodies.slice(0);\n    };\n\n    /**\n     * Clears the detector including its list of bodies.\n     * @method clear\n     * @param {detector} detector\n     */\n    Detector.clear = function(detector) {\n        detector.bodies = [];\n    };\n\n    /**\n     * Efficiently finds all collisions among all the bodies in `detector.bodies` using a broadphase algorithm.\n     * \n     * _Note:_ The specific ordering of collisions returned is not guaranteed between releases and may change for performance reasons.\n     * If a specific ordering is required then apply a sort to the resulting array.\n     * @method collisions\n     * @param {detector} detector\n     * @return {collision[]} collisions\n     */\n    Detector.collisions = function(detector) {\n        var collisions = [],\n            pairs = detector.pairs,\n            bodies = detector.bodies,\n            bodiesLength = bodies.length,\n            canCollide = Detector.canCollide,\n            collides = Collision.collides,\n            i,\n            j;\n\n        bodies.sort(Detector._compareBoundsX);\n\n        for (i = 0; i < bodiesLength; i++) {\n            var bodyA = bodies[i],\n                boundsA = bodyA.bounds,\n                boundXMax = bodyA.bounds.max.x,\n                boundYMax = bodyA.bounds.max.y,\n                boundYMin = bodyA.bounds.min.y,\n                bodyAStatic = bodyA.isStatic || bodyA.isSleeping,\n                partsALength = bodyA.parts.length,\n                partsASingle = partsALength === 1;\n\n            for (j = i + 1; j < bodiesLength; j++) {\n                var bodyB = bodies[j],\n                    boundsB = bodyB.bounds;\n\n                if (boundsB.min.x > boundXMax) {\n                    break;\n                }\n\n                if (boundYMax < boundsB.min.y || boundYMin > boundsB.max.y) {\n                    continue;\n                }\n\n                if (bodyAStatic && (bodyB.isStatic || bodyB.isSleeping)) {\n                    continue;\n                }\n\n                if (!canCollide(bodyA.collisionFilter, bodyB.collisionFilter)) {\n                    continue;\n                }\n\n                var partsBLength = bodyB.parts.length;\n\n                if (partsASingle && partsBLength === 1) {\n                    var collision = collides(bodyA, bodyB, pairs);\n\n                    if (collision) {\n                        collisions.push(collision);\n                    }\n                } else {\n                    var partsAStart = partsALength > 1 ? 1 : 0,\n                        partsBStart = partsBLength > 1 ? 1 : 0;\n                    \n                    for (var k = partsAStart; k < partsALength; k++) {\n                        var partA = bodyA.parts[k],\n                            boundsA = partA.bounds;\n\n                        for (var z = partsBStart; z < partsBLength; z++) {\n                            var partB = bodyB.parts[z],\n                                boundsB = partB.bounds;\n\n                            if (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                                continue;\n                            }\n\n                            var collision = collides(partA, partB, pairs);\n\n                            if (collision) {\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     * The comparison function used in the broadphase algorithm.\n     * Returns the signed delta of the bodies bounds on the x-axis.\n     * @private\n     * @method _sortCompare\n     * @param {body} bodyA\n     * @param {body} bodyB\n     * @return {number} The signed delta used for sorting\n     */\n    Detector._compareBoundsX = function(bodyA, bodyB) {\n        return bodyA.bounds.min.x - bodyB.bounds.min.x;\n    };\n\n    /*\n    *\n    *  Properties Documentation\n    *\n    */\n\n    /**\n     * The array of `Matter.Body` between which the detector finds collisions.\n     * \n     * _Note:_ The order of bodies in this array _is not fixed_ and will be continually managed by the detector.\n     * @property bodies\n     * @type body[]\n     * @default []\n     */\n\n    /**\n     * Optional. A `Matter.Pairs` object from which previous collision objects may be reused. Intended for internal `Matter.Engine` usage.\n     * @property pairs\n     * @type {pairs|null}\n     * @default null\n     */\n\n})();\n\n\n/***/ }),\n/* 15 */\n/***/ (function(module, exports, __webpack_require__) {\n\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 = __webpack_require__(0);\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     * - Greater than ranges e.g. `>1.2.3`\n     * - Greater than or equal 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 = /^(\\*)|(\\^|~|>=|>)?\\s*((\\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 parts = pattern.exec(range);\n        var major = Number(parts[4]);\n        var minor = Number(parts[5]);\n        var patch = Number(parts[6]);\n\n        return {\n            isRange: Boolean(parts[1] || parts[2]),\n            version: parts[3],\n            range: range,\n            operator: parts[1] || parts[2] || '',\n            major: major,\n            minor: minor,\n            patch: patch,\n            parts: [major, minor, patch],\n            prerelease: parts[7],\n            number: major * 1e8 + minor * 1e4 + patch\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 r = Plugin.versionParse(range),\n            v = Plugin.versionParse(version);\n\n        if (r.isRange) {\n            if (r.operator === '*' || version === '*') {\n                return true;\n            }\n\n            if (r.operator === '>') {\n                return v.number > r.number;\n            }\n\n            if (r.operator === '>=') {\n                return v.number >= r.number;\n            }\n\n            if (r.operator === '~') {\n                return v.major === r.major && v.minor === r.minor && v.patch >= r.patch;\n            }\n\n            if (r.operator === '^') {\n                if (r.major > 0) {\n                    return v.major === r.major && v.number >= r.number;\n                }\n\n                if (r.minor > 0) {\n                    return v.minor === r.minor && v.patch >= r.patch;\n                }\n\n                return v.patch === r.patch;\n            }\n        }\n\n        return version === range || version === '*';\n    };\n\n})();\n\n\n/***/ }),\n/* 16 */\n/***/ (function(module, exports, __webpack_require__) {\n\n/**\n* The `Matter.Render` module is a simple 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 = __webpack_require__(0);\nvar Composite = __webpack_require__(5);\nvar Bounds = __webpack_require__(1);\nvar Events = __webpack_require__(4);\nvar Vector = __webpack_require__(2);\nvar Mouse = __webpack_require__(13);\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    Render._goodFps = 30;\n    Render._goodDelta = 1000 / 60;\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            timing: {\n                historySize: 60,\n                delta: 0,\n                deltaHistory: [],\n                lastTime: 0,\n                lastTimestamp: 0,\n                lastElapsed: 0,\n                timestampElapsed: 0,\n                timestampElapsedHistory: [],\n                engineDeltaHistory: [],\n                engineElapsedHistory: [],\n                elapsedHistory: []\n            },\n            options: {\n                width: 800,\n                height: 600,\n                pixelRatio: 1,\n                background: '#14151f',\n                wireframeBackground: '#14151f',\n                hasBounds: !!options.bounds,\n                enabled: true,\n                wireframes: true,\n                showSleeping: true,\n                showDebug: false,\n                showStats: false,\n                showPerformance: 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                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        // for temporary back compatibility only\n        render.options.showBroadphase = false;\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            \n            _updateTiming(render, time);\n\n            Render.world(render, time);\n\n            if (render.options.showStats || render.options.showDebug) {\n                Render.stats(render, render.context, time);\n            }\n\n            if (render.options.showPerformance || render.options.showDebug) {\n                Render.performance(render, render.context, time);\n            }\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    };\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.setTransform(\n            render.options.pixelRatio / boundsScaleX, 0, 0, \n            render.options.pixelRatio / boundsScaleY, 0, 0\n        );\n        \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, time) {\n        var startTime = Common.now(),\n            engine = render.engine,\n            world = engine.world,\n            canvas = render.canvas,\n            context = render.context,\n            options = render.options,\n            timing = render.timing;\n\n        var 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.options.width,\n                    y: (render.bounds.max.y - render.bounds.min.y) / render.options.height\n                });\n\n                Mouse.setOffset(render.mouse, render.bounds.min);\n            }\n        } else {\n            constraints = allConstraints;\n            bodies = allBodies;\n\n            if (render.options.pixelRatio !== 1) {\n                render.context.setTransform(render.options.pixelRatio, 0, 0, render.options.pixelRatio, 0, 0);\n            }\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.hasBounds) {\n            // revert view transforms\n            Render.endViewTransform(render);\n        }\n\n        Events.trigger(render, 'afterRender', event);\n\n        // log the time elapsed computing this update\n        timing.lastElapsed = Common.now() - startTime;\n    };\n\n    /**\n     * Renders statistics about the engine and world useful for debugging.\n     * @private\n     * @method stats\n     * @param {render} render\n     * @param {RenderingContext} context\n     * @param {Number} time\n     */\n    Render.stats = function(render, context, time) {\n        var engine = render.engine,\n            world = engine.world,\n            bodies = Composite.allBodies(world),\n            parts = 0,\n            width = 55,\n            height = 44,\n            x = 0,\n            y = 0;\n        \n        // count parts\n        for (var i = 0; i < bodies.length; i += 1) {\n            parts += bodies[i].parts.length;\n        }\n\n        // sections\n        var sections = {\n            'Part': parts,\n            'Body': bodies.length,\n            'Cons': Composite.allConstraints(world).length,\n            'Comp': Composite.allComposites(world).length,\n            'Pair': engine.pairs.list.length\n        };\n\n        // background\n        context.fillStyle = '#0e0f19';\n        context.fillRect(x, y, width * 5.5, height);\n\n        context.font = '12px Arial';\n        context.textBaseline = 'top';\n        context.textAlign = 'right';\n\n        // sections\n        for (var key in sections) {\n            var section = sections[key];\n            // label\n            context.fillStyle = '#aaa';\n            context.fillText(key, x + width, y + 8);\n\n            // value\n            context.fillStyle = '#eee';\n            context.fillText(section, x + width, y + 26);\n\n            x += width;\n        }\n    };\n\n    /**\n     * Renders engine and render performance information.\n     * @private\n     * @method performance\n     * @param {render} render\n     * @param {RenderingContext} context\n     */\n    Render.performance = function(render, context) {\n        var engine = render.engine,\n            timing = render.timing,\n            deltaHistory = timing.deltaHistory,\n            elapsedHistory = timing.elapsedHistory,\n            timestampElapsedHistory = timing.timestampElapsedHistory,\n            engineDeltaHistory = timing.engineDeltaHistory,\n            engineElapsedHistory = timing.engineElapsedHistory,\n            lastEngineDelta = engine.timing.lastDelta;\n        \n        var deltaMean = _mean(deltaHistory),\n            elapsedMean = _mean(elapsedHistory),\n            engineDeltaMean = _mean(engineDeltaHistory),\n            engineElapsedMean = _mean(engineElapsedHistory),\n            timestampElapsedMean = _mean(timestampElapsedHistory),\n            rateMean = (timestampElapsedMean / deltaMean) || 0,\n            fps = (1000 / deltaMean) || 0;\n\n        var graphHeight = 4,\n            gap = 12,\n            width = 60,\n            height = 34,\n            x = 10,\n            y = 69;\n\n        // background\n        context.fillStyle = '#0e0f19';\n        context.fillRect(0, 50, gap * 4 + width * 5 + 22, height);\n\n        // show FPS\n        Render.status(\n            context, x, y, width, graphHeight, deltaHistory.length, \n            Math.round(fps) + ' fps', \n            fps / Render._goodFps,\n            function(i) { return (deltaHistory[i] / deltaMean) - 1; }\n        );\n\n        // show engine delta\n        Render.status(\n            context, x + gap + width, y, width, graphHeight, engineDeltaHistory.length,\n            lastEngineDelta.toFixed(2) + ' dt', \n            Render._goodDelta / lastEngineDelta,\n            function(i) { return (engineDeltaHistory[i] / engineDeltaMean) - 1; }\n        );\n\n        // show engine update time\n        Render.status(\n            context, x + (gap + width) * 2, y, width, graphHeight, engineElapsedHistory.length,\n            engineElapsedMean.toFixed(2) + ' ut', \n            1 - (engineElapsedMean / Render._goodFps),\n            function(i) { return (engineElapsedHistory[i] / engineElapsedMean) - 1; }\n        );\n\n        // show render time\n        Render.status(\n            context, x + (gap + width) * 3, y, width, graphHeight, elapsedHistory.length,\n            elapsedMean.toFixed(2) + ' rt', \n            1 - (elapsedMean / Render._goodFps),\n            function(i) { return (elapsedHistory[i] / elapsedMean) - 1; }\n        );\n\n        // show effective speed\n        Render.status(\n            context, x + (gap + width) * 4, y, width, graphHeight, timestampElapsedHistory.length, \n            rateMean.toFixed(2) + ' x', \n            rateMean * rateMean * rateMean,\n            function(i) { return (((timestampElapsedHistory[i] / deltaHistory[i]) / rateMean) || 0) - 1; }\n        );\n    };\n\n    /**\n     * Renders a label, indicator and a chart.\n     * @private\n     * @method status\n     * @param {RenderingContext} context\n     * @param {number} x\n     * @param {number} y\n     * @param {number} width\n     * @param {number} height\n     * @param {number} count\n     * @param {string} label\n     * @param {string} indicator\n     * @param {function} plotY\n     */\n    Render.status = function(context, x, y, width, height, count, label, indicator, plotY) {\n        // background\n        context.strokeStyle = '#888';\n        context.fillStyle = '#444';\n        context.lineWidth = 1;\n        context.fillRect(x, y + 7, width, 1);\n\n        // chart\n        context.beginPath();\n        context.moveTo(x, y + 7 - height * Common.clamp(0.4 * plotY(0), -2, 2));\n        for (var i = 0; i < width; i += 1) {\n            context.lineTo(x + i, y + 7 - (i < count ? height * Common.clamp(0.4 * plotY(i), -2, 2) : 0));\n        }\n        context.stroke();\n\n        // indicator\n        context.fillStyle = 'hsl(' + Common.clamp(25 + 95 * indicator, 0, 120) + ',100%,60%)';\n        context.fillRect(x, y - 7, 4, 4);\n\n        // label\n        context.font = '12px Arial';\n        context.textBaseline = 'middle';\n        context.textAlign = 'right';\n        context.fillStyle = '#eee';\n        context.fillText(label, x + width, y - 5);\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 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 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     * Updates render timing.\n     * @method _updateTiming\n     * @private\n     * @param {render} render\n     * @param {number} time\n     */\n    var _updateTiming = function(render, time) {\n        var engine = render.engine,\n            timing = render.timing,\n            historySize = timing.historySize,\n            timestamp = engine.timing.timestamp;\n\n        timing.delta = time - timing.lastTime || Render._goodDelta;\n        timing.lastTime = time;\n\n        timing.timestampElapsed = timestamp - timing.lastTimestamp || 0;\n        timing.lastTimestamp = timestamp;\n\n        timing.deltaHistory.unshift(timing.delta);\n        timing.deltaHistory.length = Math.min(timing.deltaHistory.length, historySize);\n\n        timing.engineDeltaHistory.unshift(engine.timing.lastDelta);\n        timing.engineDeltaHistory.length = Math.min(timing.engineDeltaHistory.length, historySize);\n\n        timing.timestampElapsedHistory.unshift(timing.timestampElapsed);\n        timing.timestampElapsedHistory.length = Math.min(timing.timestampElapsedHistory.length, historySize);\n\n        timing.engineElapsedHistory.unshift(engine.timing.lastElapsed);\n        timing.engineElapsedHistory.length = Math.min(timing.engineElapsedHistory.length, historySize);\n\n        timing.elapsedHistory.unshift(timing.lastElapsed);\n        timing.elapsedHistory.length = Math.min(timing.elapsedHistory.length, historySize);\n    };\n\n    /**\n     * Returns the mean value of the given numbers.\n     * @method _mean\n     * @private\n     * @param {Number[]} values\n     * @return {Number} the mean of given values\n     */\n    var _mean = function(values) {\n        var result = 0;\n        for (var i = 0; i < values.length; i += 1) {\n            result += values[i];\n        }\n        return (result / values.length) || 0;\n    };\n\n    /**\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     * 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     * The mouse to render if `render.options.showMousePosition` is enabled.\n     *\n     * @property mouse\n     * @type mouse\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     * See also the `options.pixelRatio` property to change render quality.\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     * See also the `options.pixelRatio` property to change render quality.\n     *\n     * @property options.height\n     * @type number\n     * @default 600\n     */\n\n    /**\n     * The [pixel ratio](https://developer.mozilla.org/en-US/docs/Web/API/Window/devicePixelRatio) to use when rendering.\n     *\n     * @property options.pixelRatio\n     * @type number\n     * @default 1\n     */\n\n    /**\n     * A CSS background color string to use when `render.options.wireframes` is disabled.\n     * This may be also set to `'transparent'` or equivalent.\n     *\n     * @property options.background\n     * @type string\n     * @default '#14151f'\n     */\n\n    /**\n     * A CSS background color string to use when `render.options.wireframes` is enabled.\n     * This may be also set to `'transparent'` or equivalent.\n     *\n     * @property options.wireframeBackground\n     * @type string\n     * @default '#14151f'\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 flag to enable or disable all debug information overlays together.  \n     * This includes and has priority over the values of:\n     *\n     * - `render.options.showStats`\n     * - `render.options.showPerformance`\n     *\n     * @property options.showDebug\n     * @type boolean\n     * @default false\n     */\n\n    /**\n     * A flag to enable or disable the engine stats info overlay.  \n     * From left to right, the values shown are:\n     *\n     * - body parts total\n     * - body total\n     * - constraints total\n     * - composites total\n     * - collision pairs total\n     *\n     * @property options.showStats\n     * @type boolean\n     * @default false\n     */\n\n    /**\n     * A flag to enable or disable performance charts.  \n     * From left to right, the values shown are:\n     *\n     * - average render frequency (e.g. 60 fps)\n     * - exact engine delta time used for last update (e.g. 16.66ms)\n     * - average engine execution duration (e.g. 5.00ms)\n     * - average render execution duration (e.g. 0.40ms)\n     * - average effective play speed (e.g. '1.00x' is 'real-time')\n     *\n     * Each value is recorded over a fixed sample of past frames (60 frames).\n     *\n     * A chart shown below each value indicates the variance from the average over the sample.\n     * The more stable or fixed the value is the flatter the chart will appear.\n     *\n     * @property options.showPerformance\n     * @type boolean\n     * @default false\n     */\n    \n    /**\n     * A flag to enable or disable rendering entirely.\n     *\n     * @property options.enabled\n     * @type boolean\n     * @default false\n     */\n\n    /**\n     * A flag to toggle wireframe rendering otherwise solid fill rendering is used.\n     *\n     * @property options.wireframes\n     * @type boolean\n     * @default true\n     */\n\n    /**\n     * A flag to enable or disable sleeping bodies indicators.\n     *\n     * @property options.showSleeping\n     * @type boolean\n     * @default true\n     */\n\n    /**\n     * A flag to enable or disable the debug information overlay.\n     *\n     * @property options.showDebug\n     * @type boolean\n     * @default false\n     */\n\n    /**\n     * A flag to enable or disable the collision broadphase debug overlay.\n     *\n     * @deprecated no longer implemented\n     * @property options.showBroadphase\n     * @type boolean\n     * @default false\n     */\n\n    /**\n     * A flag to enable or disable the body bounds debug overlay.\n     *\n     * @property options.showBounds\n     * @type boolean\n     * @default false\n     */\n\n    /**\n     * A flag to enable or disable the body velocity debug overlay.\n     *\n     * @property options.showVelocity\n     * @type boolean\n     * @default false\n     */\n\n    /**\n     * A flag to enable or disable the body collisions debug overlay.\n     *\n     * @property options.showCollisions\n     * @type boolean\n     * @default false\n     */\n\n    /**\n     * A flag to enable or disable the collision resolver separations debug overlay.\n     *\n     * @property options.showSeparations\n     * @type boolean\n     * @default false\n     */\n\n    /**\n     * A flag to enable or disable the body axes debug overlay.\n     *\n     * @property options.showAxes\n     * @type boolean\n     * @default false\n     */\n\n    /**\n     * A flag to enable or disable the body positions debug overlay.\n     *\n     * @property options.showPositions\n     * @type boolean\n     * @default false\n     */\n\n    /**\n     * A flag to enable or disable the body angle debug overlay.\n     *\n     * @property options.showAngleIndicator\n     * @type boolean\n     * @default false\n     */\n\n    /**\n     * A flag to enable or disable the body and part ids debug overlay.\n     *\n     * @property options.showIds\n     * @type boolean\n     * @default false\n     */\n\n    /**\n     * A flag to enable or disable the body vertex numbers debug overlay.\n     *\n     * @property options.showVertexNumbers\n     * @type boolean\n     * @default false\n     */\n\n    /**\n     * A flag to enable or disable the body convex hulls debug overlay.\n     *\n     * @property options.showConvexHulls\n     * @type boolean\n     * @default false\n     */\n\n    /**\n     * A flag to enable or disable the body internal edges debug overlay.\n     *\n     * @property options.showInternalEdges\n     * @type boolean\n     * @default false\n     */\n\n    /**\n     * A flag to enable or disable the mouse position debug overlay.\n     *\n     * @property options.showMousePosition\n     * @type boolean\n     * @default false\n     */\n\n})();\n\n\n/***/ }),\n/* 17 */\n/***/ (function(module, exports) {\n\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            vertex: vertex,\n            normalImpulse: 0,\n            tangentImpulse: 0\n        };\n    };\n\n})();\n\n\n/***/ }),\n/* 18 */\n/***/ (function(module, exports, __webpack_require__) {\n\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 Sleeping = __webpack_require__(7);\nvar Resolver = __webpack_require__(19);\nvar Detector = __webpack_require__(14);\nvar Pairs = __webpack_require__(20);\nvar Events = __webpack_require__(4);\nvar Composite = __webpack_require__(5);\nvar Constraint = __webpack_require__(10);\nvar Common = __webpack_require__(0);\nvar Body = __webpack_require__(6);\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(options) {\n        options = options || {};\n\n        var defaults = {\n            positionIterations: 6,\n            velocityIterations: 4,\n            constraintIterations: 2,\n            enableSleeping: false,\n            events: [],\n            plugin: {},\n            gravity: {\n                x: 0,\n                y: 1,\n                scale: 0.001\n            },\n            timing: {\n                timestamp: 0,\n                timeScale: 1,\n                lastDelta: 0,\n                lastElapsed: 0\n            }\n        };\n\n        var engine = Common.extend(defaults, options);\n\n        engine.world = options.world || Composite.create({ label: 'World' });\n        engine.pairs = options.pairs || Pairs.create();\n        engine.detector = options.detector || Detector.create();\n\n        // for temporary back compatibility only\n        engine.grid = { buckets: [] };\n        engine.world.gravity = engine.gravity;\n        engine.broadphase = engine.grid;\n        engine.metrics = {};\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        var startTime = Common.now();\n\n        delta = delta || 1000 / 60;\n        correction = correction || 1;\n\n        var world = engine.world,\n            detector = engine.detector,\n            pairs = engine.pairs,\n            timing = engine.timing,\n            timestamp = timing.timestamp,\n            i;\n\n        // increment timestamp\n        timing.timestamp += delta * timing.timeScale;\n        timing.lastDelta = 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 all bodies and all constraints in the world\n        var allBodies = Composite.allBodies(world),\n            allConstraints = Composite.allConstraints(world);\n\n        // update the detector bodies if they have changed\n        if (world.isModified) {\n            Detector.setBodies(detector, allBodies);\n        }\n\n        // reset all composite modified flags\n        if (world.isModified) {\n            Composite.setModified(world, false, false, true);\n        }\n\n        // update sleeping if enabled\n        if (engine.enableSleeping)\n            Sleeping.update(allBodies, timing.timeScale);\n\n        // apply gravity to all bodies\n        Engine._bodiesApplyGravity(allBodies, engine.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        // find all collisions\n        detector.pairs = engine.pairs;\n        var collisions = Detector.collisions(detector);\n\n        // update collision pairs\n        Pairs.update(pairs, collisions, 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        // clear force buffers\n        Engine._bodiesClearForces(allBodies);\n\n        Events.trigger(engine, 'afterUpdate', event);\n\n        // log the time elapsed computing this update\n        engine.timing.lastElapsed = Common.now() - startTime;\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 pairs and detector.\n     * @method clear\n     * @param {engine} engine\n     */\n    Engine.clear = function(engine) {\n        Pairs.clear(engine.pairs);\n        Detector.clear(engine.detector);\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     * A deprecated alias for `Runner.run`, use `Matter.Runner.run(engine)` instead and see `Matter.Runner` for more information.\n     * @deprecated use Matter.Runner.run(engine) instead\n     * @method run\n     * @param {engine} engine\n     */\n\n    /**\n    * Fired just before an update\n    *\n    * @event beforeUpdate\n    * @param {object} event An event object\n    * @param {number} event.timestamp The engine.timing.timestamp of the event\n    * @param {engine} event.source The source object of the event\n    * @param {string} 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 {object} event An event object\n    * @param {number} event.timestamp The engine.timing.timestamp of the event\n    * @param {engine} event.source The source object of the event\n    * @param {string} 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 {object} event An event object\n    * @param {pair[]} event.pairs List of affected pairs\n    * @param {number} event.timestamp The engine.timing.timestamp of the event\n    * @param {engine} event.source The source object of the event\n    * @param {string} 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 {object} event An event object\n    * @param {pair[]} event.pairs List of affected pairs\n    * @param {number} event.timestamp The engine.timing.timestamp of the event\n    * @param {engine} event.source The source object of the event\n    * @param {string} 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 {object} event An event object\n    * @param {pair[]} event.pairs List of affected pairs\n    * @param {number} event.timestamp The engine.timing.timestamp of the event\n    * @param {engine} event.source The source object of the event\n    * @param {string} 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     * A `Number` that represents the total execution time elapsed during the last `Engine.update` in milliseconds.\n     * It is updated by timing from the start of the last `Engine.update` call until it ends.\n     *\n     * This value will also include the total execution time of all event handlers directly or indirectly triggered by the engine update.\n     *\n     * @property timing.lastElapsed\n     * @type number\n     * @default 0\n     */\n\n    /**\n     * A `Number` that represents the `delta` value used in the last engine update.\n     *\n     * @property timing.lastDelta\n     * @type number\n     * @default 0\n     */\n\n    /**\n     * A `Matter.Detector` instance.\n     *\n     * @property detector\n     * @type detector\n     * @default a Matter.Detector instance\n     */\n\n    /**\n     * A `Matter.Grid` instance.\n     *\n     * @deprecated replaced by `engine.detector`\n     * @property grid\n     * @type grid\n     * @default a Matter.Grid instance\n     */\n\n    /**\n     * Replaced by and now alias for `engine.grid`.\n     *\n     * @deprecated replaced by `engine.detector`\n     * @property broadphase\n     * @type grid\n     * @default a Matter.Grid instance\n     */\n\n    /**\n     * The root `Matter.Composite` instance that will contain all bodies, constraints and other composites to be simulated by this engine.\n     *\n     * @property world\n     * @type composite\n     * @default a Matter.Composite instance\n     */\n\n    /**\n     * An object reserved for storing plugin-specific properties.\n     *\n     * @property plugin\n     * @type {}\n     */\n\n    /**\n     * The gravity to apply on all bodies in `engine.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\n\n/***/ }),\n/* 19 */\n/***/ (function(module, exports, __webpack_require__) {\n\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 = __webpack_require__(3);\nvar Bounds = __webpack_require__(1);\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            pairsLength = pairs.length;\n\n        // find total contacts on each body\n        for (i = 0; i < pairsLength; 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            contactShare,\n            positionImpulse,\n            positionDampen = Resolver._positionDampen,\n            pairsLength = pairs.length;\n\n        // find impulses required to resolve penetration\n        for (i = 0; i < pairsLength; 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            pair.separation = \n                normal.x * (bodyB.positionImpulse.x + collision.penetration.x - bodyA.positionImpulse.x)\n                + normal.y * (bodyB.positionImpulse.y + collision.penetration.y - bodyA.positionImpulse.y);\n        }\n        \n        for (i = 0; i < pairsLength; 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 = 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 = 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        var positionWarming = Resolver._positionWarming,\n            bodiesLength = bodies.length,\n            verticesTranslate = Vertices.translate,\n            boundsUpdate = Bounds.update;\n\n        for (var i = 0; i < bodiesLength; i++) {\n            var body = bodies[i],\n                positionImpulse = body.positionImpulse,\n                positionImpulseX = positionImpulse.x,\n                positionImpulseY = positionImpulse.y,\n                velocity = body.velocity;\n\n            // reset contact count\n            body.totalContacts = 0;\n\n            if (positionImpulseX !== 0 || positionImpulseY !== 0) {\n                // update body geometry\n                for (var j = 0; j < body.parts.length; j++) {\n                    var part = body.parts[j];\n                    verticesTranslate(part.vertices, positionImpulse);\n                    boundsUpdate(part.bounds, part.vertices, velocity);\n                    part.position.x += positionImpulseX;\n                    part.position.y += positionImpulseY;\n                }\n\n                // move the body without changing velocity\n                body.positionPrev.x += positionImpulseX;\n                body.positionPrev.y += positionImpulseY;\n\n                if (positionImpulseX * velocity.x + positionImpulseY * velocity.y < 0) {\n                    // reset cached impulse if the body has velocity along it\n                    positionImpulse.x = 0;\n                    positionImpulse.y = 0;\n                } else {\n                    // warm the next iteration\n                    positionImpulse.x *= positionWarming;\n                    positionImpulse.y *= 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 pairsLength = pairs.length,\n            i,\n            j;\n        \n        for (i = 0; i < pairsLength; i++) {\n            var pair = pairs[i];\n            \n            if (!pair.isActive || pair.isSensor)\n                continue;\n            \n            var contacts = pair.activeContacts,\n                contactsLength = contacts.length,\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 < contactsLength; j++) {\n                var 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                    var impulseX = normal.x * normalImpulse + tangent.x * tangentImpulse,\n                        impulseY = normal.y * normalImpulse + tangent.y * tangentImpulse;\n                    \n                    // apply impulse from contact\n                    if (!(bodyA.isStatic || bodyA.isSleeping)) {\n                        bodyA.positionPrev.x += impulseX * bodyA.inverseMass;\n                        bodyA.positionPrev.y += impulseY * bodyA.inverseMass;\n                        bodyA.anglePrev += bodyA.inverseInertia * (\n                            (contactVertex.x - bodyA.position.x) * impulseY\n                            - (contactVertex.y - bodyA.position.y) * impulseX\n                        );\n                    }\n    \n                    if (!(bodyB.isStatic || bodyB.isSleeping)) {\n                        bodyB.positionPrev.x -= impulseX * bodyB.inverseMass;\n                        bodyB.positionPrev.y -= impulseY * bodyB.inverseMass;\n                        bodyB.anglePrev -= bodyB.inverseInertia * (\n                            (contactVertex.x - bodyB.position.x) * impulseY \n                            - (contactVertex.y - bodyB.position.y) * impulseX\n                        );\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            restingThresh = Resolver._restingThresh * timeScaleSquared,\n            frictionNormalMultiplier = Resolver._frictionNormalMultiplier,\n            restingThreshTangent = Resolver._restingThreshTangent * timeScaleSquared,\n            NumberMaxValue = Number.MAX_VALUE,\n            pairsLength = pairs.length,\n            tangentImpulse,\n            maxFriction,\n            i,\n            j;\n\n        for (i = 0; i < pairsLength; 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                bodyAVelocity = bodyA.velocity,\n                bodyBVelocity = bodyB.velocity,\n                normalX = collision.normal.x,\n                normalY = collision.normal.y,\n                tangentX = collision.tangent.x,\n                tangentY = collision.tangent.y,\n                contacts = pair.activeContacts,\n                contactsLength = contacts.length,\n                contactShare = 1 / contactsLength,\n                inverseMassTotal = bodyA.inverseMass + bodyB.inverseMass,\n                friction = pair.friction * pair.frictionStatic * frictionNormalMultiplier * timeScaleSquared;\n\n            // update body velocities\n            bodyAVelocity.x = bodyA.position.x - bodyA.positionPrev.x;\n            bodyAVelocity.y = bodyA.position.y - bodyA.positionPrev.y;\n            bodyBVelocity.x = bodyB.position.x - bodyB.positionPrev.x;\n            bodyBVelocity.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 (j = 0; j < contactsLength; j++) {\n                var contact = contacts[j],\n                    contactVertex = contact.vertex;\n\n                var offsetAX = contactVertex.x - bodyA.position.x,\n                    offsetAY = contactVertex.y - bodyA.position.y,\n                    offsetBX = contactVertex.x - bodyB.position.x,\n                    offsetBY = contactVertex.y - bodyB.position.y;\n \n                var velocityPointAX = bodyAVelocity.x - offsetAY * bodyA.angularVelocity,\n                    velocityPointAY = bodyAVelocity.y + offsetAX * bodyA.angularVelocity,\n                    velocityPointBX = bodyBVelocity.x - offsetBY * bodyB.angularVelocity,\n                    velocityPointBY = bodyBVelocity.y + offsetBX * bodyB.angularVelocity;\n\n                var relativeVelocityX = velocityPointAX - velocityPointBX,\n                    relativeVelocityY = velocityPointAY - velocityPointBY;\n\n                var normalVelocity = normalX * relativeVelocityX + normalY * relativeVelocityY,\n                    tangentVelocity = tangentX * relativeVelocityX + tangentY * relativeVelocityY;\n\n                // coulomb friction\n                var normalOverlap = pair.separation + normalVelocity;\n                var normalForce = Math.min(normalOverlap, 1);\n                normalForce = normalOverlap < 0 ? 0 : normalForce;\n                \n                var frictionLimit = normalForce * friction;\n\n                if (tangentVelocity > frictionLimit || -tangentVelocity > frictionLimit) {\n                    maxFriction = tangentVelocity > 0 ? tangentVelocity : -tangentVelocity;\n                    tangentImpulse = pair.friction * (tangentVelocity > 0 ? 1 : -1) * timeScaleSquared;\n                    \n                    if (tangentImpulse < -maxFriction) {\n                        tangentImpulse = -maxFriction;\n                    } else if (tangentImpulse > maxFriction) {\n                        tangentImpulse = maxFriction;\n                    }\n                } else {\n                    tangentImpulse = tangentVelocity;\n                    maxFriction = NumberMaxValue;\n                }\n\n                // account for mass, inertia and contact offset\n                var oAcN = offsetAX * normalY - offsetAY * normalX,\n                    oBcN = offsetBX * normalY - offsetBY * normalX,\n                    share = contactShare / (inverseMassTotal + bodyA.inverseInertia * oAcN * oAcN + bodyB.inverseInertia * oBcN * oBcN);\n\n                // raw impulses\n                var normalImpulse = (1 + pair.restitution) * normalVelocity * share;\n                tangentImpulse *= share;\n\n                // handle high velocity and resting collisions separately\n                if (normalVelocity * normalVelocity > restingThresh && normalVelocity < 0) {\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 += normalImpulse;\n                    contact.normalImpulse = Math.min(contact.normalImpulse, 0);\n                    normalImpulse = contact.normalImpulse - contactNormalImpulse;\n                }\n\n                // handle high velocity and resting collisions separately\n                if (tangentVelocity * tangentVelocity > restingThreshTangent) {\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 += tangentImpulse;\n                    if (contact.tangentImpulse < -maxFriction) contact.tangentImpulse = -maxFriction;\n                    if (contact.tangentImpulse > maxFriction) contact.tangentImpulse = maxFriction;\n                    tangentImpulse = contact.tangentImpulse - contactTangentImpulse;\n                }\n\n                // total impulse from contact\n                var impulseX = normalX * normalImpulse + tangentX * tangentImpulse,\n                    impulseY = normalY * normalImpulse + tangentY * tangentImpulse;\n                \n                // apply impulse from contact\n                if (!(bodyA.isStatic || bodyA.isSleeping)) {\n                    bodyA.positionPrev.x += impulseX * bodyA.inverseMass;\n                    bodyA.positionPrev.y += impulseY * bodyA.inverseMass;\n                    bodyA.anglePrev += (offsetAX * impulseY - offsetAY * impulseX) * bodyA.inverseInertia;\n                }\n\n                if (!(bodyB.isStatic || bodyB.isSleeping)) {\n                    bodyB.positionPrev.x -= impulseX * bodyB.inverseMass;\n                    bodyB.positionPrev.y -= impulseY * bodyB.inverseMass;\n                    bodyB.anglePrev -= (offsetBX * impulseY - offsetBY * impulseX) * bodyB.inverseInertia;\n                }\n            }\n        }\n    };\n\n})();\n\n\n/***/ }),\n/* 20 */\n/***/ (function(module, exports, __webpack_require__) {\n\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 = __webpack_require__(9);\nvar Common = __webpack_require__(0);\n\n(function() {\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            pairsListLength = pairsList.length,\n            pairsTable = pairs.table,\n            collisionsLength = collisions.length,\n            collisionStart = pairs.collisionStart,\n            collisionEnd = pairs.collisionEnd,\n            collisionActive = pairs.collisionActive,\n            collision,\n            pairIndex,\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 < pairsListLength; i++) {\n            pairsList[i].confirmedActive = false;\n        }\n\n        for (i = 0; i < collisionsLength; i++) {\n            collision = collisions[i];\n            pair = collision.pair;\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                pair.confirmedActive = true;\n            } else {\n                // pair did not exist, create a new pair\n                pair = Pair.create(collision, timestamp);\n                pairsTable[pair.id] = pair;\n\n                // push the new pair\n                collisionStart.push(pair);\n                pairsList.push(pair);\n            }\n        }\n\n        // find pairs that are no longer active\n        var removePairIndex = [];\n        pairsListLength = pairsList.length;\n\n        for (i = 0; i < pairsListLength; i++) {\n            pair = pairsList[i];\n            \n            if (!pair.confirmedActive) {\n                Pair.setActive(pair, false, timestamp);\n                collisionEnd.push(pair);\n\n                if (!pair.collision.bodyA.isSleeping && !pair.collision.bodyB.isSleeping) {\n                    removePairIndex.push(i);\n                }\n            }\n        }\n\n        // remove inactive pairs\n        for (i = 0; i < removePairIndex.length; i++) {\n            pairIndex = removePairIndex[i] - i;\n            pair = pairsList[pairIndex];\n            pairsList.splice(pairIndex, 1);\n            delete pairsTable[pair.id];\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\n/***/ }),\n/* 21 */\n/***/ (function(module, exports, __webpack_require__) {\n\nvar Matter = module.exports = __webpack_require__(22);\r\n\r\nMatter.Axes = __webpack_require__(11);\r\nMatter.Bodies = __webpack_require__(12);\r\nMatter.Body = __webpack_require__(6);\r\nMatter.Bounds = __webpack_require__(1);\r\nMatter.Collision = __webpack_require__(8);\r\nMatter.Common = __webpack_require__(0);\r\nMatter.Composite = __webpack_require__(5);\r\nMatter.Composites = __webpack_require__(23);\r\nMatter.Constraint = __webpack_require__(10);\r\nMatter.Contact = __webpack_require__(17);\r\nMatter.Detector = __webpack_require__(14);\r\nMatter.Engine = __webpack_require__(18);\r\nMatter.Events = __webpack_require__(4);\r\nMatter.Grid = __webpack_require__(24);\r\nMatter.Mouse = __webpack_require__(13);\r\nMatter.MouseConstraint = __webpack_require__(25);\r\nMatter.Pair = __webpack_require__(9);\r\nMatter.Pairs = __webpack_require__(20);\r\nMatter.Plugin = __webpack_require__(15);\r\nMatter.Query = __webpack_require__(26);\r\nMatter.Render = __webpack_require__(16);\r\nMatter.Resolver = __webpack_require__(19);\r\nMatter.Runner = __webpack_require__(27);\r\nMatter.SAT = __webpack_require__(28);\r\nMatter.Sleeping = __webpack_require__(7);\r\nMatter.Svg = __webpack_require__(29);\r\nMatter.Vector = __webpack_require__(2);\r\nMatter.Vertices = __webpack_require__(3);\r\nMatter.World = __webpack_require__(30);\r\n\r\n// temporary back compatibility\r\nMatter.Engine.run = Matter.Runner.run;\r\nMatter.Common.deprecated(Matter.Engine, 'run', 'Engine.run ➤ use Matter.Runner.run(engine) instead');\r\n\n\n/***/ }),\n/* 22 */\n/***/ (function(module, exports, __webpack_require__) {\n\n/**\r\n* The `Matter` module is the top level namespace. It also includes a function for installing plugins on top of the library.\r\n*\r\n* @class Matter\r\n*/\r\n\r\nvar Matter = {};\r\n\r\nmodule.exports = Matter;\r\n\r\nvar Plugin = __webpack_require__(15);\r\nvar Common = __webpack_require__(0);\r\n\r\n(function() {\r\n\r\n    /**\r\n     * The library name.\r\n     * @property name\r\n     * @readOnly\r\n     * @type {String}\r\n     */\r\n    Matter.name = 'matter-js';\r\n\r\n    /**\r\n     * The library version.\r\n     * @property version\r\n     * @readOnly\r\n     * @type {String}\r\n     */\r\n    Matter.version =  true ? \"0.18.0\" : undefined;\r\n\r\n    /**\r\n     * A list of plugin dependencies to be installed. These are normally set and installed through `Matter.use`.\r\n     * Alternatively you may set `Matter.uses` manually and install them by calling `Plugin.use(Matter)`.\r\n     * @property uses\r\n     * @type {Array}\r\n     */\r\n    Matter.uses = [];\r\n\r\n    /**\r\n     * The plugins that have been installed through `Matter.Plugin.install`. Read only.\r\n     * @property used\r\n     * @readOnly\r\n     * @type {Array}\r\n     */\r\n    Matter.used = [];\r\n\r\n    /**\r\n     * Installs the given plugins on the `Matter` namespace.\r\n     * This is a short-hand for `Plugin.use`, see it for more information.\r\n     * Call this function once at the start of your code, with all of the plugins you wish to install as arguments.\r\n     * Avoid calling this function multiple times unless you intend to manually control installation order.\r\n     * @method use\r\n     * @param ...plugin {Function} The plugin(s) to install on `base` (multi-argument).\r\n     */\r\n    Matter.use = function() {\r\n        Plugin.use(Matter, Array.prototype.slice.call(arguments));\r\n    };\r\n\r\n    /**\r\n     * Chains a function to excute before the original function on the given `path` relative to `Matter`.\r\n     * See also docs for `Common.chain`.\r\n     * @method before\r\n     * @param {string} path The path relative to `Matter`\r\n     * @param {function} func The function to chain before the original\r\n     * @return {function} The chained function that replaced the original\r\n     */\r\n    Matter.before = function(path, func) {\r\n        path = path.replace(/^Matter./, '');\r\n        return Common.chainPathBefore(Matter, path, func);\r\n    };\r\n\r\n    /**\r\n     * Chains a function to excute after the original function on the given `path` relative to `Matter`.\r\n     * See also docs for `Common.chain`.\r\n     * @method after\r\n     * @param {string} path The path relative to `Matter`\r\n     * @param {function} func The function to chain after the original\r\n     * @return {function} The chained function that replaced the original\r\n     */\r\n    Matter.after = function(path, func) {\r\n        path = path.replace(/^Matter./, '');\r\n        return Common.chainPathAfter(Matter, path, func);\r\n    };\r\n\r\n})();\r\n\n\n/***/ }),\n/* 23 */\n/***/ (function(module, exports, __webpack_require__) {\n\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 = __webpack_require__(5);\nvar Constraint = __webpack_require__(10);\nvar Common = __webpack_require__(0);\nvar Body = __webpack_require__(6);\nvar Bodies = __webpack_require__(12);\nvar deprecated = Common.deprecated;\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     * This has now moved to the [newtonsCradle example](https://github.com/liabru/matter-js/blob/master/examples/newtonsCradle.js), follow that instead as this function is deprecated here.\n     * @deprecated moved to newtonsCradle example\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    deprecated(Composites, 'newtonsCradle', 'Composites.newtonsCradle ➤ moved to newtonsCradle example');\n    \n    /**\n     * This has now moved to the [car example](https://github.com/liabru/matter-js/blob/master/examples/car.js), follow that instead as this function is deprecated here.\n     * @deprecated moved to car example\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    deprecated(Composites, 'car', 'Composites.car ➤ moved to car example');\n\n    /**\n     * This has now moved to the [softBody example](https://github.com/liabru/matter-js/blob/master/examples/softBody.js)\n     * and the [cloth example](https://github.com/liabru/matter-js/blob/master/examples/cloth.js), follow those instead as this function is deprecated here.\n     * @deprecated moved to softBody and cloth examples\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    deprecated(Composites, 'softBody', 'Composites.softBody ➤ moved to softBody and cloth examples');\n})();\n\n\n/***/ }),\n/* 24 */\n/***/ (function(module, exports, __webpack_require__) {\n\n/**\n* This module has now been replaced by `Matter.Detector`.\n*\n* All usage should be migrated to `Matter.Detector` or another alternative.\n* For back-compatibility purposes this module will remain for a short term and then later removed in a future release.\n*\n* The `Matter.Grid` module contains methods for creating and manipulating collision broadphase grid structures.\n*\n* @class Grid\n* @deprecated\n*/\n\nvar Grid = {};\n\nmodule.exports = Grid;\n\nvar Pair = __webpack_require__(9);\nvar Common = __webpack_require__(0);\nvar deprecated = Common.deprecated;\n\n(function() {\n\n    /**\n     * Creates a new grid.\n     * @deprecated replaced by Matter.Detector\n     * @method create\n     * @param {} options\n     * @return {grid} A new grid\n     */\n    Grid.create = function(options) {\n        var defaults = {\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     * @deprecated replaced by Matter.Detector\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        for (i = 0; i < bodies.length; i++) {\n            var body = bodies[i];\n\n            if (body.isSleeping && !forceUpdate)\n                continue;\n\n            // temporary back compatibility bounds check\n            if (world.bounds && (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                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    deprecated(Grid, 'update', 'Grid.update ➤ replaced by Matter.Detector');\n\n    /**\n     * Clears the grid.\n     * @deprecated replaced by Matter.Detector\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    deprecated(Grid, 'clear', 'Grid.clear ➤ replaced by Matter.Detector');\n\n    /**\n     * Finds the union of two regions.\n     * @method _regionUnion\n     * @deprecated replaced by Matter.Detector\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     * @deprecated replaced by Matter.Detector\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     * @deprecated replaced by Matter.Detector\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     * @deprecated replaced by Matter.Detector\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     * @deprecated replaced by Matter.Detector\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     * @deprecated replaced by Matter.Detector\n     * @private\n     * @param {} grid\n     * @param {} bucket\n     * @param {} body\n     */\n    Grid._bucketAddBody = function(grid, bucket, body) {\n        var gridPairs = grid.pairs,\n            pairId = Pair.id,\n            bucketLength = bucket.length,\n            i;\n\n        // add new pairs\n        for (i = 0; i < bucketLength; 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 id = pairId(body, bodyB),\n                pair = gridPairs[id];\n\n            if (pair) {\n                pair[2] += 1;\n            } else {\n                gridPairs[id] = [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     * @deprecated replaced by Matter.Detector\n     * @private\n     * @param {} grid\n     * @param {} bucket\n     * @param {} body\n     */\n    Grid._bucketRemoveBody = function(grid, bucket, body) {\n        var gridPairs = grid.pairs,\n            pairId = Pair.id,\n            i;\n\n        // remove from bucket\n        bucket.splice(Common.indexOf(bucket, body), 1);\n\n        var bucketLength = bucket.length;\n\n        // update pair counts\n        for (i = 0; i < bucketLength; i++) {\n            // keep track of the number of buckets the pair exists in\n            // important for _createActivePairsList to work\n            var pair = gridPairs[pairId(body, bucket[i])];\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     * @deprecated replaced by Matter.Detector\n     * @private\n     * @param {} grid\n     * @return [] pairs\n     */\n    Grid._createActivePairsList = function(grid) {\n        var pair,\n            gridPairs = grid.pairs,\n            pairKeys = Common.keys(gridPairs),\n            pairKeysLength = pairKeys.length,\n            pairs = [],\n            k;\n\n        // iterate over grid.pairs\n        for (k = 0; k < pairKeysLength; k++) {\n            pair = gridPairs[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 gridPairs[pairKeys[k]];\n            }\n        }\n\n        return pairs;\n    };\n    \n})();\n\n\n/***/ }),\n/* 25 */\n/***/ (function(module, exports, __webpack_require__) {\n\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 = __webpack_require__(3);\nvar Sleeping = __webpack_require__(7);\nvar Mouse = __webpack_require__(13);\nvar Events = __webpack_require__(4);\nvar Detector = __webpack_require__(14);\nvar Constraint = __webpack_require__(10);\nvar Composite = __webpack_require__(5);\nvar Common = __webpack_require__(0);\nvar Bounds = __webpack_require__(1);\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\n/***/ }),\n/* 26 */\n/***/ (function(module, exports, __webpack_require__) {\n\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 = __webpack_require__(2);\nvar Collision = __webpack_require__(8);\nvar Bounds = __webpack_require__(1);\nvar Bodies = __webpack_require__(12);\nvar Vertices = __webpack_require__(3);\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 {collision[]} Collisions\n     */\n    Query.collides = function(body, bodies) {\n        var collisions = [],\n            bodiesLength = bodies.length,\n            bounds = body.bounds,\n            collides = Collision.collides,\n            overlaps = Bounds.overlaps;\n\n        for (var i = 0; i < bodiesLength; i++) {\n            var bodyA = bodies[i],\n                partsALength = bodyA.parts.length,\n                partsAStart = partsALength === 1 ? 0 : 1;\n            \n            if (overlaps(bodyA.bounds, bounds)) {\n                for (var j = partsAStart; j < partsALength; j++) {\n                    var part = bodyA.parts[j];\n\n                    if (overlaps(part.bounds, bounds)) {\n                        var collision = collides(part, body);\n\n                        if (collision) {\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 {collision[]} 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\n/***/ }),\n/* 27 */\n/***/ (function(module, exports, __webpack_require__) {\n\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 = __webpack_require__(4);\nvar Engine = __webpack_require__(18);\nvar Common = __webpack_require__(0);\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     * 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\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\n        // update\n        Events.trigger(runner, 'beforeUpdate', event);\n        Engine.update(engine, delta, correction);\n        Events.trigger(runner, 'afterUpdate', event);\n\n        Events.trigger(runner, 'afterTick', event);\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    *\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\n/***/ }),\n/* 28 */\n/***/ (function(module, exports, __webpack_require__) {\n\n/**\n* This module has now been replaced by `Matter.Collision`.\n*\n* All usage should be migrated to `Matter.Collision`.\n* For back-compatibility purposes this module will remain for a short term and then later removed in a future release.\n*\n* The `Matter.SAT` module contains methods for detecting collisions using the Separating Axis Theorem.\n*\n* @class SAT\n* @deprecated\n*/\n\nvar SAT = {};\n\nmodule.exports = SAT;\n\nvar Collision = __webpack_require__(8);\nvar Common = __webpack_require__(0);\nvar deprecated = Common.deprecated;\n\n(function() {\n\n    /**\n     * Detect collision between two bodies using the Separating Axis Theorem.\n     * @deprecated replaced by Collision.collides\n     * @method collides\n     * @param {body} bodyA\n     * @param {body} bodyB\n     * @return {collision} collision\n     */\n    SAT.collides = function(bodyA, bodyB) {\n        return Collision.collides(bodyA, bodyB);\n    };\n\n    deprecated(SAT, 'collides', 'SAT.collides ➤ replaced by Collision.collides');\n\n})();\n\n\n/***/ }),\n/* 29 */\n/***/ (function(module, exports, __webpack_require__) {\n\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 = __webpack_require__(1);\nvar Common = __webpack_require__(0);\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     * You must load the `pathseg.js` polyfill on newer browsers.\n     * @method pathToVertices\n     * @param {SVGPathElement} path\n     * @param {Number} [sampleLength=15]\n     * @return {Vector[]} points\n     */\n    Svg.pathToVertices = function(path, sampleLength) {\n        if (typeof window !== 'undefined' && !('SVGPathSeg' in window)) {\n            Common.warn('Svg.pathToVertices: SVGPathSeg not defined, a polyfill is required.');\n        }\n\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\n/***/ }),\n/* 30 */\n/***/ (function(module, exports, __webpack_require__) {\n\n/**\n* This module has now been replaced by `Matter.Composite`.\n*\n* All usage should be migrated to the equivalent functions found on `Matter.Composite`.\n* For example `World.add(world, body)` now becomes `Composite.add(world, body)`.\n*\n* The property `world.gravity` has been moved to `engine.gravity`.\n*\n* For back-compatibility purposes this module will remain as a direct alias to `Matter.Composite` in the short term during migration.\n* Eventually this alias module will be marked as deprecated and then later removed in a future release.\n*\n* @class World\n*/\n\nvar World = {};\n\nmodule.exports = World;\n\nvar Composite = __webpack_require__(5);\nvar Common = __webpack_require__(0);\n\n(function() {\n\n    /**\n     * See above, aliases for back compatibility only\n     */\n    World.create = Composite.create;\n    World.add = Composite.add;\n    World.remove = Composite.remove;\n    World.clear = Composite.clear;\n    World.addComposite = Composite.addComposite;\n    World.addBody = Composite.addBody;\n    World.addConstraint = Composite.addConstraint;\n\n})();\n\n\n/***/ })\n/******/ ]);\n});","import type { ObserverInstanceCallback } from './index';\n\nconst observerMap = new Map<\n  string,\n  {\n    id: string;\n    observer: IntersectionObserver;\n    elements: Map<Element, Array<ObserverInstanceCallback>>;\n  }\n>();\n\nconst RootIds: WeakMap<Element | Document, string> = new WeakMap();\nlet rootId = 0;\n\nlet unsupportedValue: boolean | undefined = undefined;\n\n/**\n * What should be the default behavior if the IntersectionObserver is unsupported?\n * Ideally the polyfill has been loaded, you can have the following happen:\n * - `undefined`: Throw an error\n * - `true` or `false`: Set the `inView` value to this regardless of intersection state\n * **/\nexport function defaultFallbackInView(inView: boolean | undefined) {\n  unsupportedValue = inView;\n}\n\n/**\n * Generate a unique ID for the root element\n * @param root\n */\nfunction getRootId(root: IntersectionObserverInit['root']) {\n  if (!root) return '0';\n  if (RootIds.has(root)) return RootIds.get(root);\n  rootId += 1;\n  RootIds.set(root, rootId.toString());\n  return RootIds.get(root);\n}\n\n/**\n * Convert the options to a string Id, based on the values.\n * Ensures we can reuse the same observer when observing elements with the same options.\n * @param options\n */\nexport function optionsToId(options: IntersectionObserverInit) {\n  return Object.keys(options)\n    .sort()\n    .filter((key) => options[key] !== undefined)\n    .map((key) => {\n      return `${key}_${\n        key === 'root' ? getRootId(options.root) : options[key]\n      }`;\n    })\n    .toString();\n}\n\nfunction createObserver(options: IntersectionObserverInit) {\n  // Create a unique ID for this observer instance, based on the root, root margin and threshold.\n  let id = optionsToId(options);\n  let instance = observerMap.get(id);\n\n  if (!instance) {\n    // Create a map of elements this observer is going to observe. Each element has a list of callbacks that should be triggered, once it comes into view.\n    const elements = new Map<Element, Array<ObserverInstanceCallback>>();\n    let thresholds: number[] | readonly number[];\n\n    const observer = new IntersectionObserver((entries) => {\n      entries.forEach((entry) => {\n        // While it would be nice if you could just look at isIntersecting to determine if the component is inside the viewport, browsers can't agree on how to use it.\n        // -Firefox ignores `threshold` when considering `isIntersecting`, so it will never be false again if `threshold` is > 0\n        const inView =\n          entry.isIntersecting &&\n          thresholds.some((threshold) => entry.intersectionRatio >= threshold);\n\n        // @ts-ignore support IntersectionObserver v2\n        if (options.trackVisibility && typeof entry.isVisible === 'undefined') {\n          // The browser doesn't support Intersection Observer v2, falling back to v1 behavior.\n          // @ts-ignore\n          entry.isVisible = inView;\n        }\n\n        elements.get(entry.target)?.forEach((callback) => {\n          callback(inView, entry);\n        });\n      });\n    }, options);\n\n    // Ensure we have a valid thresholds array. If not, use the threshold from the options\n    thresholds =\n      observer.thresholds ||\n      (Array.isArray(options.threshold)\n        ? options.threshold\n        : [options.threshold || 0]);\n\n    instance = {\n      id,\n      observer,\n      elements,\n    };\n\n    observerMap.set(id, instance);\n  }\n\n  return instance;\n}\n\n/**\n * @param element - DOM Element to observe\n * @param callback - Callback function to trigger when intersection status changes\n * @param options - Intersection Observer options\n * @param fallbackInView - Fallback inView value.\n * @return Function - Cleanup function that should be triggered to unregister the observer\n */\nexport function observe(\n  element: Element,\n  callback: ObserverInstanceCallback,\n  options: IntersectionObserverInit = {},\n  fallbackInView = unsupportedValue,\n) {\n  if (\n    typeof window.IntersectionObserver === 'undefined' &&\n    fallbackInView !== undefined\n  ) {\n    const bounds = element.getBoundingClientRect();\n    callback(fallbackInView, {\n      isIntersecting: fallbackInView,\n      target: element,\n      intersectionRatio:\n        typeof options.threshold === 'number' ? options.threshold : 0,\n      time: 0,\n      boundingClientRect: bounds,\n      intersectionRect: bounds,\n      rootBounds: bounds,\n    });\n    return () => {\n      // Nothing to cleanup\n    };\n  }\n  // An observer with the same options can be reused, so lets use this fact\n  const { id, observer, elements } = createObserver(options);\n\n  // Register the callback listener for this element\n  let callbacks = elements.get(element) || [];\n  if (!elements.has(element)) {\n    elements.set(element, callbacks);\n  }\n\n  callbacks.push(callback);\n  observer.observe(element);\n\n  return function unobserve() {\n    // Remove the callback from the callback list\n    callbacks.splice(callbacks.indexOf(callback), 1);\n\n    if (callbacks.length === 0) {\n      // No more callback exists for element, so destroy it\n      elements.delete(element);\n      observer.unobserve(element);\n    }\n\n    if (elements.size === 0) {\n      // No more elements are being observer by this instance, so destroy it\n      observer.disconnect();\n      observerMap.delete(id);\n    }\n  };\n}\n","import * as React from 'react';\nimport type { IntersectionObserverProps, PlainChildrenProps } from './index';\nimport { observe } from './observe';\n\ntype State = {\n  inView: boolean;\n  entry?: IntersectionObserverEntry;\n};\n\nfunction isPlainChildren(\n  props: IntersectionObserverProps | PlainChildrenProps,\n): props is PlainChildrenProps {\n  return typeof props.children !== 'function';\n}\n\n/**\n ## Render props\n\n To use the `<InView>` component, you pass it a function. It will be called\n whenever the state changes, with the new value of `inView`. In addition to the\n `inView` prop, children also receive a `ref` that should be set on the\n containing DOM element. This is the element that the IntersectionObserver will\n monitor.\n\n If you need it, you can also access the\n [`IntersectionObserverEntry`](https://developer.mozilla.org/en-US/docs/Web/API/IntersectionObserverEntry)\n on `entry`, giving you access to all the details about the current intersection\n state.\n\n ```jsx\n import { InView } from 'react-intersection-observer';\n\n const Component = () => (\n <InView>\n {({ inView, ref, entry }) => (\n      <div ref={ref}>\n        <h2>{`Header inside viewport ${inView}.`}</h2>\n      </div>\n    )}\n </InView>\n );\n\n export default Component;\n ```\n\n ## Plain children\n\n You can pass any element to the `<InView />`, and it will handle creating the\n wrapping DOM element. Add a handler to the `onChange` method, and control the\n state in your own component. Any extra props you add to `<InView>` will be\n passed to the HTML element, allowing you set the `className`, `style`, etc.\n\n ```jsx\n import { InView } from 'react-intersection-observer';\n\n const Component = () => (\n <InView as=\"div\" onChange={(inView, entry) => console.log('Inview:', inView)}>\n <h2>Plain children are always rendered. Use onChange to monitor state.</h2>\n </InView>\n );\n\n export default Component;\n ```\n */\nexport class InView extends React.Component<\n  IntersectionObserverProps | PlainChildrenProps,\n  State\n> {\n  constructor(props: IntersectionObserverProps | PlainChildrenProps) {\n    super(props);\n    this.state = {\n      inView: !!props.initialInView,\n      entry: undefined,\n    };\n  }\n\n  componentDidUpdate(prevProps: IntersectionObserverProps) {\n    // If a IntersectionObserver option changed, reinit the observer\n    if (\n      prevProps.rootMargin !== this.props.rootMargin ||\n      prevProps.root !== this.props.root ||\n      prevProps.threshold !== this.props.threshold ||\n      prevProps.skip !== this.props.skip ||\n      prevProps.trackVisibility !== this.props.trackVisibility ||\n      prevProps.delay !== this.props.delay\n    ) {\n      this.unobserve();\n      this.observeNode();\n    }\n  }\n\n  componentWillUnmount() {\n    this.unobserve();\n    this.node = null;\n  }\n\n  node: Element | null = null;\n  _unobserveCb: (() => void) | null = null;\n\n  observeNode() {\n    if (!this.node || this.props.skip) return;\n    const {\n      threshold,\n      root,\n      rootMargin,\n      trackVisibility,\n      delay,\n      fallbackInView,\n    } = this.props;\n\n    this._unobserveCb = observe(\n      this.node,\n      this.handleChange,\n      {\n        threshold,\n        root,\n        rootMargin,\n        // @ts-ignore\n        trackVisibility,\n        // @ts-ignore\n        delay,\n      },\n      fallbackInView,\n    );\n  }\n\n  unobserve() {\n    if (this._unobserveCb) {\n      this._unobserveCb();\n      this._unobserveCb = null;\n    }\n  }\n\n  handleNode = (node?: Element | null) => {\n    if (this.node) {\n      // Clear the old observer, before we start observing a new element\n      this.unobserve();\n\n      if (!node && !this.props.triggerOnce && !this.props.skip) {\n        // Reset the state if we get a new node, and we aren't ignoring updates\n        this.setState({ inView: !!this.props.initialInView, entry: undefined });\n      }\n    }\n\n    this.node = node ? node : null;\n    this.observeNode();\n  };\n\n  handleChange = (inView: boolean, entry: IntersectionObserverEntry) => {\n    if (inView && this.props.triggerOnce) {\n      // If `triggerOnce` is true, we should stop observing the element.\n      this.unobserve();\n    }\n    if (!isPlainChildren(this.props)) {\n      // Store the current State, so we can pass it to the children in the next render update\n      // There's no reason to update the state for plain children, since it's not used in the rendering.\n      this.setState({ inView, entry });\n    }\n    if (this.props.onChange) {\n      // If the user is actively listening for onChange, always trigger it\n      this.props.onChange(inView, entry);\n    }\n  };\n\n  render() {\n    if (!isPlainChildren(this.props)) {\n      const { inView, entry } = this.state;\n      return this.props.children({ inView, entry, ref: this.handleNode });\n    }\n\n    const {\n      children,\n      as,\n      triggerOnce,\n      threshold,\n      root,\n      rootMargin,\n      onChange,\n      skip,\n      trackVisibility,\n      delay,\n      initialInView,\n      fallbackInView,\n      ...props\n    } = this.props;\n\n    return React.createElement(\n      as || 'div',\n      { ref: this.handleNode, ...props },\n      children,\n    );\n  }\n}\n","import * as React from 'react';\nimport type { InViewHookResponse, IntersectionOptions } from './index';\nimport { observe } from './observe';\n\ntype State = {\n  inView: boolean;\n  entry?: IntersectionObserverEntry;\n};\n\n/**\n * React Hooks make it easy to monitor the `inView` state of your components. Call\n * the `useInView` hook with the (optional) [options](#options) you need. It will\n * return an array containing a `ref`, the `inView` status and the current\n * [`entry`](https://developer.mozilla.org/en-US/docs/Web/API/IntersectionObserverEntry).\n * Assign the `ref` to the DOM element you want to monitor, and the hook will\n * report the status.\n *\n * @example\n * ```jsx\n * import React from 'react';\n * import { useInView } from 'react-intersection-observer';\n *\n * const Component = () => {\n *   const { ref, inView, entry } = useInView({\n *       threshold: 0,\n *   });\n *\n *   return (\n *     <div ref={ref}>\n *       <h2>{`Header inside viewport ${inView}.`}</h2>\n *     </div>\n *   );\n * };\n * ```\n */\nexport function useInView({\n  threshold,\n  delay,\n  trackVisibility,\n  rootMargin,\n  root,\n  triggerOnce,\n  skip,\n  initialInView,\n  fallbackInView,\n  onChange,\n}: IntersectionOptions = {}): InViewHookResponse {\n  const [ref, setRef] = React.useState<Element | null>(null);\n  const callback = React.useRef<IntersectionOptions['onChange']>();\n  const [state, setState] = React.useState<State>({\n    inView: !!initialInView,\n    entry: undefined,\n  });\n\n  // Store the onChange callback in a `ref`, so we can access the latest instance\n  // inside the `useEffect`, but without triggering a rerender.\n  callback.current = onChange;\n\n  React.useEffect(\n    () => {\n      // Ensure we have node ref, and that we shouldn't skip observing\n      if (skip || !ref) return;\n\n      let unobserve: (() => void) | undefined = observe(\n        ref,\n        (inView, entry) => {\n          setState({\n            inView,\n            entry,\n          });\n          if (callback.current) callback.current(inView, entry);\n\n          if (entry.isIntersecting && triggerOnce && unobserve) {\n            // If it should only trigger once, unobserve the element after it's inView\n            unobserve();\n            unobserve = undefined;\n          }\n        },\n        {\n          root,\n          rootMargin,\n          threshold,\n          // @ts-ignore\n          trackVisibility,\n          // @ts-ignore\n          delay,\n        },\n        fallbackInView,\n      );\n\n      return () => {\n        if (unobserve) {\n          unobserve();\n        }\n      };\n    },\n    // We break the rule here, because we aren't including the actual `threshold` variable\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n    [\n      // If the threshold is an array, convert it to a string, so it won't change between renders.\n      // eslint-disable-next-line react-hooks/exhaustive-deps\n      Array.isArray(threshold) ? threshold.toString() : threshold,\n      ref,\n      root,\n      rootMargin,\n      triggerOnce,\n      skip,\n      trackVisibility,\n      fallbackInView,\n      delay,\n    ],\n  );\n\n  const entryTarget = state.entry?.target;\n\n  React.useEffect(() => {\n    if (!ref && entryTarget && !triggerOnce && !skip) {\n      // If we don't have a node ref, then reset the state (unless the hook is set to only `triggerOnce` or `skip`)\n      // This ensures we correctly reflect the current state - If you aren't observing anything, then nothing is inView\n      setState({\n        inView: !!initialInView,\n        entry: undefined,\n      });\n    }\n  }, [ref, entryTarget, triggerOnce, skip, initialInView]);\n\n  const result = [setRef, state.inView, state.entry] as InViewHookResponse;\n\n  // Support object destructuring, by adding the specific values.\n  result.ref = result[0];\n  result.inView = result[1];\n  result.entry = result[2];\n\n  return result;\n}\n"],"names":["factory","modules","installedModules","__webpack_require__","moduleId","exports","module","i","l","call","m","c","d","name","getter","o","Object","defineProperty","enumerable","get","r","Symbol","toStringTag","value","t","mode","__esModule","ns","create","key","bind","n","object","property","prototype","hasOwnProperty","p","s","Common","_nextId","_seed","_nowStartTime","Date","_warnedOnce","_decomp","extend","obj","deep","argsStart","deepClone","arguments","length","source","prop","constructor","clone","keys","push","values","path","begin","end","split","slice","set","val","parts","shuffle","array","j","Math","floor","random","temp","choose","choices","isElement","HTMLElement","nodeType","nodeName","isArray","toString","isFunction","isPlainObject","isString","clamp","min","max","sign","now","window","performance","webkitNow","_seededRandom","colorToNumber","colorString","replace","charAt","parseInt","logLevel","log","console","apply","concat","Array","info","warn","warnOnce","message","join","deprecated","warning","chain","nextId","indexOf","haystack","needle","map","list","func","mapped","topologicalSort","graph","result","visited","node","_topologicalSort","neighbors","neighbor","funcs","_chained","lastResult","args","chainPathBefore","base","chainPathAfter","setDecomp","decomp","getDecomp","global","e","Bounds","vertices","bounds","x","y","update","velocity","Infinity","vertex","contains","point","overlaps","boundsA","boundsB","translate","vector","shift","position","deltaX","deltaY","Vector","magnitude","sqrt","magnitudeSquared","rotate","angle","output","cos","sin","rotateAbout","normalise","dot","vectorA","vectorB","cross","cross3","vectorC","add","sub","mult","scalar","div","perp","negate","neg","atan2","_temp","Vertices","points","body","index","isInternal","fromPath","match","parseFloat","centre","area","mean","average","signed","abs","inertia","mass","numerator","denominator","v","verticesLength","translateX","translateY","dx","dy","pointX","pointY","nextVertex","scale","scaleX","scaleY","delta","chamfer","radius","quality","qualityMin","qualityMax","newVertices","prevVertex","currentRadius","prevNormal","nextNormal","diagonalRadius","pow","radiusVector","midNormal","scaledVertex","precision","theta","acos","clockwiseSort","sort","vertexA","vertexB","isConvex","k","z","flag","hull","upper","lower","pop","Events","on","eventNames","callback","names","events","off","callbacks","newCallbacks","trigger","event","eventClone","Composite","Body","options","id","type","parent","isModified","bodies","constraints","composites","label","plugin","cache","allBodies","allConstraints","allComposites","setModified","composite","updateParents","updateChildren","childComposite","objects","addBody","addConstraint","addComposite","constraint","remove","removeBody","removeConstraint","removeComposite","compositeA","compositeB","removeCompositeAt","splice","removeBodyAt","removeConstraintAt","clear","keepStatic","filter","isStatic","move","rebase","translation","recursive","rotation","setPosition","Sleeping","Axes","_inertiaScale","_nextCollidingGroupId","_nextNonCollidingGroupId","_nextCategory","defaults","force","torque","positionImpulse","constraintImpulse","totalContacts","speed","angularSpeed","angularVelocity","isSensor","isSleeping","motion","sleepThreshold","density","restitution","friction","frictionStatic","frictionAir","collisionFilter","category","mask","group","slop","timeScale","render","visible","opacity","strokeStyle","fillStyle","lineWidth","sprite","xScale","yScale","xOffset","yOffset","circleRadius","positionPrev","anglePrev","axes","_original","_initProperties","nextGroup","isNonColliding","nextCategory","defaultFillStyle","defaultStrokeStyle","defaultLineWidth","settings","setStatic","setMass","setDensity","setInertia","setVertices","setAngle","setVelocity","setAngularVelocity","setParts","setCentre","part","inverseMass","inverseInertia","moment","fromVertices","autoHull","hullCentre","total","_totalProperties","relative","totalArea","totalInertia","deltaTime","correction","deltaTimeSquared","velocityPrevX","velocityPrevY","applyForce","offset","properties","_motionWakeThreshold","_motionSleepThreshold","_minBias","timeFactor","minMotion","maxMotion","sleepCounter","afterCollisions","pairs","pair","isActive","collision","bodyA","bodyB","sleepingBody","movingBody","wasSleeping","Collision","Pair","_supports","_overlapAB","overlap","axis","_overlapBA","collided","parentA","parentB","depth","normal","tangent","penetration","supports","collides","_overlapAxes","minOverlap","table","minAxis","minAxisX","minAxisY","supportsB","_findSupports","supportCount","supportsA","verticesA","verticesB","overlapAB","overlapBA","verticesALength","verticesBLength","verticesAX","verticesAY","verticesBX","verticesBY","axesLength","overlapMin","Number","MAX_VALUE","overlapAxisNumber","axisX","axisY","minA","minB","maxA","maxB","_projectToAxis","projection","direction","vertexC","distance","bodyAPositionX","bodyAPositionY","normalX","normalY","nearestDistance","Contact","timestamp","contacts","activeContacts","separation","confirmedActive","timeCreated","timeUpdated","parentAVerticesLength","support","contactId","contact","setActive","Constraint","_warming","_torqueDampen","_minLength","pointA","pointB","initialPointA","initialPointB","stiffness","damping","angularStiffness","angleA","angleB","anchors","preSolveAll","impulse","solveAll","fixedA","fixedB","solve","pointAWorld","pointBWorld","currentLength","share","normalVelocity","relativeVelocity","difference","massTotal","resistanceTotal","zero","postSolveAll","gradient","toFixed","xx","Bodies","rectangle","width","height","trapezoid","slope","verticesPath","x1","x2","x3","circle","maxSides","sides","ceil","polygon","PI","yy","vertexSets","flagInternal","removeCollinear","minimumArea","removeDuplicatePoints","canDecomp","Boolean","quickDecomp","concave","makeCCW","removeCollinearPoints","decomposed","chunkVertices","partA","partB","pav","pbv","da","db","Mouse","element","mouse","document","absolute","mousedownPosition","mouseupPosition","wheelDelta","button","pixelRatio","getAttribute","sourceEvents","mousemove","mousedown","mouseup","mousewheel","_getRelativeMousePosition","changedTouches","preventDefault","detail","setElement","addEventListener","clearSourceEvents","setOffset","setScale","elementBounds","getBoundingClientRect","rootNode","documentElement","parentNode","scrollX","undefined","pageXOffset","scrollLeft","scrollY","pageYOffset","scrollTop","touches","pageX","left","pageY","top","clientWidth","clientHeight","Detector","setBodies","detector","collisions","bodiesLength","canCollide","_compareBoundsX","boundXMax","boundYMax","boundYMin","bodyAStatic","partsALength","partsASingle","partsBLength","partsBStart","filterA","filterB","Plugin","_registry","register","isPlugin","registered","pluginVersion","versionParse","version","number","registeredVersion","resolve","dependency","dependencyParse","range","install","isUsed","used","isFor","parsed","for","versionSatisfies","use","plugins","uses","dependencies","sortedDependencies","status","_warned","tracked","parsedBase","resolved","test","pattern","exec","major","minor","patch","isRange","operator","prerelease","Render","_requestAnimationFrame","_cancelAnimationFrame","requestAnimationFrame","webkitRequestAnimationFrame","mozRequestAnimationFrame","msRequestAnimationFrame","setTimeout","cancelAnimationFrame","mozCancelAnimationFrame","webkitCancelAnimationFrame","msCancelAnimationFrame","_goodFps","_goodDelta","controller","engine","canvas","frameRequestId","timing","historySize","deltaHistory","lastTime","lastTimestamp","lastElapsed","timestampElapsed","timestampElapsedHistory","engineDeltaHistory","engineElapsedHistory","elapsedHistory","background","wireframeBackground","hasBounds","enabled","wireframes","showSleeping","showDebug","showStats","showPerformance","showBounds","showVelocity","showCollisions","showSeparations","showAxes","showPositions","showAngleIndicator","showIds","showVertexNumbers","showConvexHulls","showInternalEdges","showMousePosition","_createCanvas","context","getContext","textures","showBroadphase","setPixelRatio","appendChild","run","loop","time","_updateTiming","world","stats","stop","_getPixelRatio","setAttribute","style","lookAt","padding","center","viewHeight","outerRatio","innerRatio","startViewTransform","boundsWidth","boundsHeight","boundsScaleX","boundsScaleY","setTransform","endViewTransform","startTime","currentBackground","_applyBackground","globalCompositeOperation","fillRect","enableSleeping","bodyConvexHulls","bodyWireframes","bodyBounds","bodyAxes","bodyPositions","bodyVelocity","bodyIds","separations","vertexNumbers","mousePosition","sections","font","textBaseline","textAlign","section","fillText","lastEngineDelta","lastDelta","deltaMean","_mean","elapsedMean","engineDeltaMean","engineElapsedMean","rateMean","fps","gap","round","count","indicator","plotY","beginPath","moveTo","lineTo","stroke","start","arc","closePath","coils","fill","globalAlpha","texture","_getTexture","drawImage","rect","normalPosX","normalPosY","inspector","selected","item","data","setLineDash","selectStart","selectBounds","unshift","createElement","oncontextmenu","onselectstart","devicePixelRatio","webkitBackingStorePixelRatio","mozBackingStorePixelRatio","msBackingStorePixelRatio","oBackingStorePixelRatio","backingStorePixelRatio","imagePath","image","Image","src","cssBackground","backgroundSize","normalImpulse","tangentImpulse","Engine","Resolver","Pairs","positionIterations","velocityIterations","constraintIterations","gravity","grid","buckets","broadphase","metrics","_bodiesApplyGravity","_bodiesUpdate","collisionStart","preSolvePosition","solvePosition","postSolvePosition","preSolveVelocity","solveVelocity","collisionActive","collisionEnd","_bodiesClearForces","merge","engineA","engineB","gravityScale","worldBounds","_restingThresh","_restingThreshTangent","_positionDampen","_positionWarming","_frictionNormalMultiplier","activeCount","pairsLength","contactShare","positionDampen","positionWarming","verticesTranslate","boundsUpdate","positionImpulseX","positionImpulseY","contactsLength","contactVertex","impulseX","impulseY","maxFriction","timeScaleSquared","restingThresh","frictionNormalMultiplier","restingThreshTangent","NumberMaxValue","bodyAVelocity","bodyBVelocity","tangentX","tangentY","inverseMassTotal","offsetAX","offsetAY","offsetBX","offsetBY","velocityPointAX","velocityPointAY","relativeVelocityX","relativeVelocityY","tangentVelocity","normalOverlap","normalForce","frictionLimit","oAcN","oBcN","contactNormalImpulse","contactTangentImpulse","pairIndex","pairsList","pairsListLength","pairsTable","collisionsLength","removePairIndex","Matter","Composites","Grid","MouseConstraint","Query","Runner","SAT","Svg","World","before","after","stack","columns","rows","columnGap","rowGap","lastBody","row","maxHeight","column","bodyHeight","bodyWidth","xOffsetA","yOffsetA","xOffsetB","yOffsetB","bodyAHeight","bodyAWidth","bodyBHeight","mesh","crossBrace","col","bodyC","pyramid","actualRows","lastBodyWidth","newtonsCradle","size","car","wheelSize","wheelAOffset","wheelBOffset","wheelA","wheelB","axelA","axelB","softBody","particleRadius","particleOptions","constraintOptions","bucketWidth","bucketHeight","forceUpdate","bucket","bucketId","gridChanged","newRegion","_getRegion","region","union","_regionUnion","startCol","endCol","startRow","endRow","_getBucketId","isInsideNewRegion","isInsideOldRegion","_bucketRemoveBody","_createBucket","_bucketAddBody","_createActivePairsList","regionA","regionB","_createRegion","gridPairs","pairId","bucketLength","pairKeys","pairKeysLength","mouseConstraint","_triggerEvents","mouseEvents","partsAStart","ray","startPoint","endPoint","rayWidth","rayAngle","rayLength","rayX","rayY","outside","_frameTimeout","clearTimeout","runner","deltaSampleSize","counterTimestamp","frameCounter","timePrev","timeScalePrev","isFixed","deltaMin","deltaMax","tick","pathToVertices","sampleLength","il","segment","segments","segmentsQueue","lastSegment","lastPoint","lx","ly","addPoint","px","py","pathSegType","isRelative","addSegmentPoint","segType","pathSegTypeAsLetter","toUpperCase","_svgPathToAbsolute","getTotalLength","pathSegList","numberOfItems","getItem","getPathSegAtLength","getPointAtLength","x0","y0","y1","y2","segs","len","seg","replaceItem","createSVGPathSegMovetoAbs","createSVGPathSegLinetoAbs","createSVGPathSegLinetoHorizontalAbs","createSVGPathSegLinetoVerticalAbs","createSVGPathSegCurvetoCubicAbs","createSVGPathSegCurvetoCubicSmoothAbs","createSVGPathSegCurvetoQuadraticAbs","createSVGPathSegCurvetoQuadraticSmoothAbs","createSVGPathSegArcAbs","r1","r2","largeArcFlag","sweepFlag","observerMap","Map","RootIds","WeakMap","rootId","unsupportedValue","optionsToId","root","has","createObserver","instance","thresholds","elements","observer","IntersectionObserver","entries","forEach","entry","inView","isIntersecting","some","threshold","intersectionRatio","trackVisibility","isVisible","target","observe","fallbackInView","boundingClientRect","intersectionRect","rootBounds","delete","unobserve","disconnect","isPlainChildren","props","children","InView","_unobserveCb","handleNode","triggerOnce","skip","setState","initialInView","observeNode","handleChange","onChange","state","componentDidUpdate","prevProps","rootMargin","this","delay","componentWillUnmount","ref","as","React","useInView","setRef","current","entryTarget"],"sourceRoot":""}