{"version":3,"file":"653c0bec162b5ca95a97.chunk.js","mappings":"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","sources":["webpack://ch.enlightware.gamecreator/./node_modules/idb/build/esm/index.js","webpack://ch.enlightware.gamecreator/./node_modules/idb/build/esm/wrap-idb-value.js","webpack://ch.enlightware.gamecreator/./node_modules/idb/build/esm/async-iterators.js","webpack://ch.enlightware.gamecreator/./node_modules/planck-js/lib/Body.js","webpack://ch.enlightware.gamecreator/./node_modules/planck-js/lib/Contact.js","webpack://ch.enlightware.gamecreator/./node_modules/planck-js/lib/Fixture.js","webpack://ch.enlightware.gamecreator/./node_modules/planck-js/lib/Joint.js","webpack://ch.enlightware.gamecreator/./node_modules/planck-js/lib/Manifold.js","webpack://ch.enlightware.gamecreator/./node_modules/planck-js/lib/Settings.js","webpack://ch.enlightware.gamecreator/./node_modules/planck-js/lib/Shape.js","webpack://ch.enlightware.gamecreator/./node_modules/planck-js/lib/Solver.js","webpack://ch.enlightware.gamecreator/./node_modules/planck-js/lib/World.js","webpack://ch.enlightware.gamecreator/./node_modules/planck-js/lib/collision/AABB.js","webpack://ch.enlightware.gamecreator/./node_modules/planck-js/lib/collision/BroadPhase.js","webpack://ch.enlightware.gamecreator/./node_modules/planck-js/lib/collision/Distance.js","webpack://ch.enlightware.gamecreator/./node_modules/planck-js/lib/collision/DynamicTree.js","webpack://ch.enlightware.gamecreator/./node_modules/planck-js/lib/collision/TimeOfImpact.js","webpack://ch.enlightware.gamecreator/./node_modules/planck-js/lib/common/Mat22.js","webpack://ch.enlightware.gamecreator/./node_modules/planck-js/lib/common/Mat33.js","webpack://ch.enlightware.gamecreator/./node_modules/planck-js/lib/common/Math.js","webpack://ch.enlightware.gamecreator/./node_modules/planck-js/lib/common/Position.js","webpack://ch.enlightware.gamecreator/./node_modules/planck-js/lib/common/Rot.js","webpack://ch.enlightware.gamecreator/./node_modules/planck-js/lib/common/Sweep.js","webpack://ch.enlightware.gamecreator/./node_modules/planck-js/lib/common/Transform.js","webpack://ch.enlightware.gamecreator/./node_modules/planck-js/lib/common/Vec2.js","webpack://ch.enlightware.gamecreator/./node_modules/planck-js/lib/common/Vec3.js","webpack://ch.enlightware.gamecreator/./node_modules/planck-js/lib/common/Velocity.js","webpack://ch.enlightware.gamecreator/./node_modules/planck-js/lib/common/stats.js","webpack://ch.enlightware.gamecreator/./node_modules/planck-js/lib/index.js","webpack://ch.enlightware.gamecreator/./node_modules/planck-js/lib/joint/DistanceJoint.js","webpack://ch.enlightware.gamecreator/./node_modules/planck-js/lib/joint/FrictionJoint.js","webpack://ch.enlightware.gamecreator/./node_modules/planck-js/lib/joint/GearJoint.js","webpack://ch.enlightware.gamecreator/./node_modules/planck-js/lib/joint/MotorJoint.js","webpack://ch.enlightware.gamecreator/./node_modules/planck-js/lib/joint/MouseJoint.js","webpack://ch.enlightware.gamecreator/./node_modules/planck-js/lib/joint/PrismaticJoint.js","webpack://ch.enlightware.gamecreator/./node_modules/planck-js/lib/joint/PulleyJoint.js","webpack://ch.enlightware.gamecreator/./node_modules/planck-js/lib/joint/RevoluteJoint.js","webpack://ch.enlightware.gamecreator/./node_modules/planck-js/lib/joint/RopeJoint.js","webpack://ch.enlightware.gamecreator/./node_modules/planck-js/lib/joint/WeldJoint.js","webpack://ch.enlightware.gamecreator/./node_modules/planck-js/lib/joint/WheelJoint.js","webpack://ch.enlightware.gamecreator/./node_modules/planck-js/lib/serializer/index.js","webpack://ch.enlightware.gamecreator/./node_modules/planck-js/lib/shape/BoxShape.js","webpack://ch.enlightware.gamecreator/./node_modules/planck-js/lib/shape/ChainShape.js","webpack://ch.enlightware.gamecreator/./node_modules/planck-js/lib/shape/CircleShape.js","webpack://ch.enlightware.gamecreator/./node_modules/planck-js/lib/shape/CollideCircle.js","webpack://ch.enlightware.gamecreator/./node_modules/planck-js/lib/shape/CollideCirclePolygone.js","webpack://ch.enlightware.gamecreator/./node_modules/planck-js/lib/shape/CollideEdgeCircle.js","webpack://ch.enlightware.gamecreator/./node_modules/planck-js/lib/shape/CollideEdgePolygon.js","webpack://ch.enlightware.gamecreator/./node_modules/planck-js/lib/shape/CollidePolygon.js","webpack://ch.enlightware.gamecreator/./node_modules/planck-js/lib/shape/EdgeShape.js","webpack://ch.enlightware.gamecreator/./node_modules/planck-js/lib/shape/PolygonShape.js","webpack://ch.enlightware.gamecreator/./node_modules/planck-js/lib/util/Pool.js","webpack://ch.enlightware.gamecreator/./node_modules/planck-js/lib/util/Timer.js","webpack://ch.enlightware.gamecreator/./node_modules/planck-js/lib/util/common.js","webpack://ch.enlightware.gamecreator/./node_modules/planck-js/lib/util/options.js"],"sourcesContent":["import { w as wrap, r as replaceTraps } from './wrap-idb-value.js';\nexport { u as unwrap, w as wrap } from './wrap-idb-value.js';\n\n/**\n * Open a database.\n *\n * @param name Name of the database.\n * @param version Schema version.\n * @param callbacks Additional callbacks.\n */\nfunction openDB(name, version, { blocked, upgrade, blocking, terminated } = {}) {\n    const request = indexedDB.open(name, version);\n    const openPromise = wrap(request);\n    if (upgrade) {\n        request.addEventListener('upgradeneeded', (event) => {\n            upgrade(wrap(request.result), event.oldVersion, event.newVersion, wrap(request.transaction));\n        });\n    }\n    if (blocked)\n        request.addEventListener('blocked', () => blocked());\n    openPromise\n        .then((db) => {\n        if (terminated)\n            db.addEventListener('close', () => terminated());\n        if (blocking)\n            db.addEventListener('versionchange', () => blocking());\n    })\n        .catch(() => { });\n    return openPromise;\n}\n/**\n * Delete a database.\n *\n * @param name Name of the database.\n */\nfunction deleteDB(name, { blocked } = {}) {\n    const request = indexedDB.deleteDatabase(name);\n    if (blocked)\n        request.addEventListener('blocked', () => blocked());\n    return wrap(request).then(() => undefined);\n}\n\nconst readMethods = ['get', 'getKey', 'getAll', 'getAllKeys', 'count'];\nconst writeMethods = ['put', 'add', 'delete', 'clear'];\nconst cachedMethods = new Map();\nfunction getMethod(target, prop) {\n    if (!(target instanceof IDBDatabase &&\n        !(prop in target) &&\n        typeof prop === 'string')) {\n        return;\n    }\n    if (cachedMethods.get(prop))\n        return cachedMethods.get(prop);\n    const targetFuncName = prop.replace(/FromIndex$/, '');\n    const useIndex = prop !== targetFuncName;\n    const isWrite = writeMethods.includes(targetFuncName);\n    if (\n    // Bail if the target doesn't exist on the target. Eg, getAll isn't in Edge.\n    !(targetFuncName in (useIndex ? IDBIndex : IDBObjectStore).prototype) ||\n        !(isWrite || readMethods.includes(targetFuncName))) {\n        return;\n    }\n    const method = async function (storeName, ...args) {\n        // isWrite ? 'readwrite' : undefined gzipps better, but fails in Edge :(\n        const tx = this.transaction(storeName, isWrite ? 'readwrite' : 'readonly');\n        let target = tx.store;\n        if (useIndex)\n            target = target.index(args.shift());\n        // Must reject if op rejects.\n        // If it's a write operation, must reject if tx.done rejects.\n        // Must reject with op rejection first.\n        // Must resolve with op value.\n        // Must handle both promises (no unhandled rejections)\n        return (await Promise.all([\n            target[targetFuncName](...args),\n            isWrite && tx.done,\n        ]))[0];\n    };\n    cachedMethods.set(prop, method);\n    return method;\n}\nreplaceTraps((oldTraps) => ({\n    ...oldTraps,\n    get: (target, prop, receiver) => getMethod(target, prop) || oldTraps.get(target, prop, receiver),\n    has: (target, prop) => !!getMethod(target, prop) || oldTraps.has(target, prop),\n}));\n\nexport { deleteDB, openDB };\n","const instanceOfAny = (object, constructors) => constructors.some((c) => object instanceof c);\n\nlet idbProxyableTypes;\nlet cursorAdvanceMethods;\n// This is a function to prevent it throwing up in node environments.\nfunction getIdbProxyableTypes() {\n    return (idbProxyableTypes ||\n        (idbProxyableTypes = [\n            IDBDatabase,\n            IDBObjectStore,\n            IDBIndex,\n            IDBCursor,\n            IDBTransaction,\n        ]));\n}\n// This is a function to prevent it throwing up in node environments.\nfunction getCursorAdvanceMethods() {\n    return (cursorAdvanceMethods ||\n        (cursorAdvanceMethods = [\n            IDBCursor.prototype.advance,\n            IDBCursor.prototype.continue,\n            IDBCursor.prototype.continuePrimaryKey,\n        ]));\n}\nconst cursorRequestMap = new WeakMap();\nconst transactionDoneMap = new WeakMap();\nconst transactionStoreNamesMap = new WeakMap();\nconst transformCache = new WeakMap();\nconst reverseTransformCache = new WeakMap();\nfunction promisifyRequest(request) {\n    const promise = new Promise((resolve, reject) => {\n        const unlisten = () => {\n            request.removeEventListener('success', success);\n            request.removeEventListener('error', error);\n        };\n        const success = () => {\n            resolve(wrap(request.result));\n            unlisten();\n        };\n        const error = () => {\n            reject(request.error);\n            unlisten();\n        };\n        request.addEventListener('success', success);\n        request.addEventListener('error', error);\n    });\n    promise\n        .then((value) => {\n        // Since cursoring reuses the IDBRequest (*sigh*), we cache it for later retrieval\n        // (see wrapFunction).\n        if (value instanceof IDBCursor) {\n            cursorRequestMap.set(value, request);\n        }\n        // Catching to avoid \"Uncaught Promise exceptions\"\n    })\n        .catch(() => { });\n    // This mapping exists in reverseTransformCache but doesn't doesn't exist in transformCache. This\n    // is because we create many promises from a single IDBRequest.\n    reverseTransformCache.set(promise, request);\n    return promise;\n}\nfunction cacheDonePromiseForTransaction(tx) {\n    // Early bail if we've already created a done promise for this transaction.\n    if (transactionDoneMap.has(tx))\n        return;\n    const done = new Promise((resolve, reject) => {\n        const unlisten = () => {\n            tx.removeEventListener('complete', complete);\n            tx.removeEventListener('error', error);\n            tx.removeEventListener('abort', error);\n        };\n        const complete = () => {\n            resolve();\n            unlisten();\n        };\n        const error = () => {\n            reject(tx.error || new DOMException('AbortError', 'AbortError'));\n            unlisten();\n        };\n        tx.addEventListener('complete', complete);\n        tx.addEventListener('error', error);\n        tx.addEventListener('abort', error);\n    });\n    // Cache it for later retrieval.\n    transactionDoneMap.set(tx, done);\n}\nlet idbProxyTraps = {\n    get(target, prop, receiver) {\n        if (target instanceof IDBTransaction) {\n            // Special handling for transaction.done.\n            if (prop === 'done')\n                return transactionDoneMap.get(target);\n            // Polyfill for objectStoreNames because of Edge.\n            if (prop === 'objectStoreNames') {\n                return target.objectStoreNames || transactionStoreNamesMap.get(target);\n            }\n            // Make tx.store return the only store in the transaction, or undefined if there are many.\n            if (prop === 'store') {\n                return receiver.objectStoreNames[1]\n                    ? undefined\n                    : receiver.objectStore(receiver.objectStoreNames[0]);\n            }\n        }\n        // Else transform whatever we get back.\n        return wrap(target[prop]);\n    },\n    set(target, prop, value) {\n        target[prop] = value;\n        return true;\n    },\n    has(target, prop) {\n        if (target instanceof IDBTransaction &&\n            (prop === 'done' || prop === 'store')) {\n            return true;\n        }\n        return prop in target;\n    },\n};\nfunction replaceTraps(callback) {\n    idbProxyTraps = callback(idbProxyTraps);\n}\nfunction wrapFunction(func) {\n    // Due to expected object equality (which is enforced by the caching in `wrap`), we\n    // only create one new func per func.\n    // Edge doesn't support objectStoreNames (booo), so we polyfill it here.\n    if (func === IDBDatabase.prototype.transaction &&\n        !('objectStoreNames' in IDBTransaction.prototype)) {\n        return function (storeNames, ...args) {\n            const tx = func.call(unwrap(this), storeNames, ...args);\n            transactionStoreNamesMap.set(tx, storeNames.sort ? storeNames.sort() : [storeNames]);\n            return wrap(tx);\n        };\n    }\n    // Cursor methods are special, as the behaviour is a little more different to standard IDB. In\n    // IDB, you advance the cursor and wait for a new 'success' on the IDBRequest that gave you the\n    // cursor. It's kinda like a promise that can resolve with many values. That doesn't make sense\n    // with real promises, so each advance methods returns a new promise for the cursor object, or\n    // undefined if the end of the cursor has been reached.\n    if (getCursorAdvanceMethods().includes(func)) {\n        return function (...args) {\n            // Calling the original function with the proxy as 'this' causes ILLEGAL INVOCATION, so we use\n            // the original object.\n            func.apply(unwrap(this), args);\n            return wrap(cursorRequestMap.get(this));\n        };\n    }\n    return function (...args) {\n        // Calling the original function with the proxy as 'this' causes ILLEGAL INVOCATION, so we use\n        // the original object.\n        return wrap(func.apply(unwrap(this), args));\n    };\n}\nfunction transformCachableValue(value) {\n    if (typeof value === 'function')\n        return wrapFunction(value);\n    // This doesn't return, it just creates a 'done' promise for the transaction,\n    // which is later returned for transaction.done (see idbObjectHandler).\n    if (value instanceof IDBTransaction)\n        cacheDonePromiseForTransaction(value);\n    if (instanceOfAny(value, getIdbProxyableTypes()))\n        return new Proxy(value, idbProxyTraps);\n    // Return the same value back if we're not going to transform it.\n    return value;\n}\nfunction wrap(value) {\n    // We sometimes generate multiple promises from a single IDBRequest (eg when cursoring), because\n    // IDB is weird and a single IDBRequest can yield many responses, so these can't be cached.\n    if (value instanceof IDBRequest)\n        return promisifyRequest(value);\n    // If we've already transformed this value before, reuse the transformed value.\n    // This is faster, but it also provides object equality.\n    if (transformCache.has(value))\n        return transformCache.get(value);\n    const newValue = transformCachableValue(value);\n    // Not all types are transformed.\n    // These may be primitive types, so they can't be WeakMap keys.\n    if (newValue !== value) {\n        transformCache.set(value, newValue);\n        reverseTransformCache.set(newValue, value);\n    }\n    return newValue;\n}\nconst unwrap = (value) => reverseTransformCache.get(value);\n\nexport { reverseTransformCache as a, instanceOfAny as i, replaceTraps as r, unwrap as u, wrap as w };\n","import { r as replaceTraps, i as instanceOfAny, a as reverseTransformCache, u as unwrap } from './wrap-idb-value.js';\n\nconst advanceMethodProps = ['continue', 'continuePrimaryKey', 'advance'];\nconst methodMap = {};\nconst advanceResults = new WeakMap();\nconst ittrProxiedCursorToOriginalProxy = new WeakMap();\nconst cursorIteratorTraps = {\n    get(target, prop) {\n        if (!advanceMethodProps.includes(prop))\n            return target[prop];\n        let cachedFunc = methodMap[prop];\n        if (!cachedFunc) {\n            cachedFunc = methodMap[prop] = function (...args) {\n                advanceResults.set(this, ittrProxiedCursorToOriginalProxy.get(this)[prop](...args));\n            };\n        }\n        return cachedFunc;\n    },\n};\nasync function* iterate(...args) {\n    // tslint:disable-next-line:no-this-assignment\n    let cursor = this;\n    if (!(cursor instanceof IDBCursor)) {\n        cursor = await cursor.openCursor(...args);\n    }\n    if (!cursor)\n        return;\n    cursor = cursor;\n    const proxiedCursor = new Proxy(cursor, cursorIteratorTraps);\n    ittrProxiedCursorToOriginalProxy.set(proxiedCursor, cursor);\n    // Map this double-proxy back to the original, so other cursor methods work.\n    reverseTransformCache.set(proxiedCursor, unwrap(cursor));\n    while (cursor) {\n        yield proxiedCursor;\n        // If one of the advancing methods was not called, call continue().\n        cursor = await (advanceResults.get(proxiedCursor) || cursor.continue());\n        advanceResults.delete(proxiedCursor);\n    }\n}\nfunction isIteratorProp(target, prop) {\n    return ((prop === Symbol.asyncIterator &&\n        instanceOfAny(target, [IDBIndex, IDBObjectStore, IDBCursor])) ||\n        (prop === 'iterate' && instanceOfAny(target, [IDBIndex, IDBObjectStore])));\n}\nreplaceTraps((oldTraps) => ({\n    ...oldTraps,\n    get(target, prop, receiver) {\n        if (isIteratorProp(target, prop))\n            return iterate;\n        return oldTraps.get(target, prop, receiver);\n    },\n    has(target, prop) {\n        return isIteratorProp(target, prop) || oldTraps.has(target, prop);\n    },\n}));\n","/*\n * Planck.js\n * The MIT License\n * Copyright (c) 2021 Erin Catto, Ali Shakiba\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 all\n * 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 THE\n * SOFTWARE.\n */\n\nvar _DEBUG = typeof DEBUG === 'undefined' ? false : DEBUG;\nvar _ASSERT = typeof ASSERT === 'undefined' ? false : ASSERT;\n\nmodule.exports = Body;\n\nvar common = require('./util/common');\nvar options = require('./util/options');\n\nvar Vec2 = require('./common/Vec2');\nvar Rot = require('./common/Rot');\nvar Math = require('./common/Math');\nvar Sweep = require('./common/Sweep');\nvar Transform = require('./common/Transform');\nvar Velocity = require('./common/Velocity');\nvar Position = require('./common/Position');\n\nvar Fixture = require('./Fixture');\nvar Shape = require('./Shape');\n\nvar staticBody = Body.STATIC = 'static';\nvar kinematicBody = Body.KINEMATIC = 'kinematic';\nvar dynamicBody = Body.DYNAMIC = 'dynamic';\n\n/**\n * @typedef {Object} BodyDef\n *\n * @prop type Body types are static, kinematic, or dynamic. Note: if a dynamic\n *       body would have zero mass, the mass is set to one.\n *\n * @prop position The world position of the body. Avoid creating bodies at the\n *       origin since this can lead to many overlapping shapes.\n *\n * @prop angle The world angle of the body in radians.\n *\n * @prop linearVelocity The linear velocity of the body's origin in world\n *       co-ordinates.\n *\n * @prop angularVelocity\n *\n * @prop linearDamping Linear damping is use to reduce the linear velocity. The\n *       damping parameter can be larger than 1.0 but the damping effect becomes\n *       sensitive to the time step when the damping parameter is large.\n *\n * @prop angularDamping Angular damping is use to reduce the angular velocity.\n *       The damping parameter can be larger than 1.0 but the damping effect\n *       becomes sensitive to the time step when the damping parameter is large.\n *\n * @prop fixedRotation Should this body be prevented from rotating? Useful for\n *       characters.\n *\n * @prop bullet Is this a fast moving body that should be prevented from\n *       tunneling through other moving bodies? Note that all bodies are\n *       prevented from tunneling through kinematic and static bodies. This\n *       setting is only considered on dynamic bodies. Warning: You should use\n *       this flag sparingly since it increases processing time.\n *\n * @prop active Does this body start out active?\n *\n * @prop awake Is this body initially awake or sleeping?\n *\n * @prop allowSleep Set this flag to false if this body should never fall\n *       asleep. Note that this increases CPU usage.\n */\nvar BodyDef = {\n  type : staticBody,\n  position : Vec2.zero(),\n  angle : 0.0,\n\n  linearVelocity : Vec2.zero(),\n  angularVelocity : 0.0,\n\n  linearDamping : 0.0,\n  angularDamping : 0.0,\n\n  fixedRotation : false,\n  bullet : false,\n  gravityScale : 1.0,\n\n  allowSleep : true,\n  awake : true,\n  active : true,\n\n  userData : null\n};\n\n/**\n * @class\n * \n * A rigid body composed of one or more fixtures.\n * \n * @param {World} world\n * @param {BodyDef} def\n */\nfunction Body(world, def) {\n\n  def = options(def, BodyDef);\n\n  _ASSERT && common.assert(Vec2.isValid(def.position));\n  _ASSERT && common.assert(Vec2.isValid(def.linearVelocity));\n  _ASSERT && common.assert(Math.isFinite(def.angle));\n  _ASSERT && common.assert(Math.isFinite(def.angularVelocity));\n  _ASSERT && common.assert(Math.isFinite(def.angularDamping) && def.angularDamping >= 0.0);\n  _ASSERT && common.assert(Math.isFinite(def.linearDamping) && def.linearDamping >= 0.0);\n\n  this.m_world = world;\n\n  this.m_awakeFlag = def.awake;\n  this.m_autoSleepFlag = def.allowSleep;\n  this.m_bulletFlag = def.bullet;\n  this.m_fixedRotationFlag = def.fixedRotation;\n  this.m_activeFlag = def.active;\n\n  this.m_islandFlag = false;\n  this.m_toiFlag = false;\n\n  this.m_userData = def.userData;\n  this.m_type = def.type;\n\n  if (this.m_type == dynamicBody) {\n    this.m_mass = 1.0;\n    this.m_invMass = 1.0;\n  } else {\n    this.m_mass = 0.0;\n    this.m_invMass = 0.0;\n  }\n\n  // Rotational inertia about the center of mass.\n  this.m_I = 0.0;\n  this.m_invI = 0.0;\n\n  // the body origin transform\n  this.m_xf = Transform.identity();\n  this.m_xf.p = Vec2.clone(def.position);\n  this.m_xf.q.setAngle(def.angle);\n\n  // the swept motion for CCD\n  this.m_sweep = new Sweep();\n  this.m_sweep.setTransform(this.m_xf);\n\n  // position and velocity correction\n  this.c_velocity = new Velocity();\n  this.c_position = new Position();\n\n  this.m_force = Vec2.zero();\n  this.m_torque = 0.0;\n\n  this.m_linearVelocity = Vec2.clone(def.linearVelocity);\n  this.m_angularVelocity = def.angularVelocity;\n\n  this.m_linearDamping = def.linearDamping;\n  this.m_angularDamping = def.angularDamping;\n  this.m_gravityScale = def.gravityScale;\n\n  this.m_sleepTime = 0.0;\n\n  this.m_jointList = null;\n  this.m_contactList = null;\n  this.m_fixtureList = null;\n\n  this.m_prev = null;\n  this.m_next = null;\n\n  this.m_destroyed = false;\n}\n\nBody.prototype._serialize = function() {\n  var fixtures = [];\n  for (var f = this.m_fixtureList; f; f = f.m_next) {\n    fixtures.push(f);\n  }\n  return {\n    type: this.m_type,\n    bullet: this.m_bulletFlag,\n    position: this.m_xf.p,\n    angle: this.m_xf.q.getAngle(),\n    linearVelocity: this.m_linearVelocity,\n    angularVelocity: this.m_angularVelocity,\n    fixtures: fixtures,\n  };\n};\n\nBody._deserialize = function(data, world, restore) {\n  var body = new Body(world, data);\n\n  if (data.fixtures) {\n    for (var i = data.fixtures.length - 1; i >= 0; i--) {\n      var fixture = restore(Fixture, data.fixtures[i], body);\n      body._addFixture(fixture);\n    }\n  }\n  return body;\n};\n\nBody.prototype.isWorldLocked = function() {\n  return this.m_world && this.m_world.isLocked() ? true : false;\n};\n\nBody.prototype.getWorld = function() {\n  return this.m_world;\n};\n\nBody.prototype.getNext = function() {\n  return this.m_next;\n};\n\nBody.prototype.setUserData = function(data) {\n  this.m_userData = data;\n};\n\nBody.prototype.getUserData = function() {\n  return this.m_userData;\n};\n\nBody.prototype.getFixtureList = function() {\n  return this.m_fixtureList;\n};\n\nBody.prototype.getJointList = function() {\n  return this.m_jointList;\n};\n\n/**\n * Warning: this list changes during the time step and you may miss some\n * collisions if you don't use ContactListener.\n */\nBody.prototype.getContactList = function() {\n  return this.m_contactList;\n};\n\nBody.prototype.isStatic = function() {\n  return this.m_type == staticBody;\n};\n\nBody.prototype.isDynamic = function() {\n  return this.m_type == dynamicBody;\n};\n\nBody.prototype.isKinematic = function() {\n  return this.m_type == kinematicBody;\n};\n\n/**\n * This will alter the mass and velocity.\n */\nBody.prototype.setStatic = function() {\n  this.setType(staticBody);\n  return this;\n};\n\nBody.prototype.setDynamic = function() {\n  this.setType(dynamicBody);\n  return this;\n};\n\nBody.prototype.setKinematic = function() {\n  this.setType(kinematicBody);\n  return this;\n};\n\n/**\n * @private\n */\nBody.prototype.getType = function() {\n  return this.m_type;\n};\n\n/**\n * \n * @private\n */\nBody.prototype.setType = function(type) {\n  _ASSERT && common.assert(type === staticBody || type === kinematicBody || type === dynamicBody);\n  _ASSERT && common.assert(this.isWorldLocked() == false);\n\n  if (this.isWorldLocked() == true) {\n    return;\n  }\n\n  if (this.m_type == type) {\n    return;\n  }\n\n  this.m_type = type;\n\n  this.resetMassData();\n\n  if (this.m_type == staticBody) {\n    this.m_linearVelocity.setZero();\n    this.m_angularVelocity = 0.0;\n    this.m_sweep.forward();\n    this.synchronizeFixtures();\n  }\n\n  this.setAwake(true);\n\n  this.m_force.setZero();\n  this.m_torque = 0.0;\n\n  // Delete the attached contacts.\n  var ce = this.m_contactList;\n  while (ce) {\n    var ce0 = ce;\n    ce = ce.next;\n    this.m_world.destroyContact(ce0.contact);\n  }\n  this.m_contactList = null;\n\n  // Touch the proxies so that new contacts will be created (when appropriate)\n  var broadPhase = this.m_world.m_broadPhase;\n  for (var f = this.m_fixtureList; f; f = f.m_next) {\n    var proxyCount = f.m_proxyCount;\n    for (var i = 0; i < proxyCount; ++i) {\n      broadPhase.touchProxy(f.m_proxies[i].proxyId);\n    }\n  }\n};\n\nBody.prototype.isBullet = function() {\n  return this.m_bulletFlag;\n};\n\n/**\n * Should this body be treated like a bullet for continuous collision detection?\n */\nBody.prototype.setBullet = function(flag) {\n  this.m_bulletFlag = !!flag;\n};\n\nBody.prototype.isSleepingAllowed = function() {\n  return this.m_autoSleepFlag;\n};\n\nBody.prototype.setSleepingAllowed = function(flag) {\n  this.m_autoSleepFlag = !!flag;\n  if (this.m_autoSleepFlag == false) {\n    this.setAwake(true);\n  }\n};\n\nBody.prototype.isAwake = function() {\n  return this.m_awakeFlag;\n};\n\n/**\n * Set the sleep state of the body. A sleeping body has very low CPU cost.\n * \n * @param flag Set to true to wake the body, false to put it to sleep.\n */\nBody.prototype.setAwake = function(flag) {\n  if (flag) {\n    if (this.m_awakeFlag == false) {\n      this.m_awakeFlag = true;\n      this.m_sleepTime = 0.0;\n    }\n  } else {\n    this.m_awakeFlag = false;\n    this.m_sleepTime = 0.0;\n    this.m_linearVelocity.setZero();\n    this.m_angularVelocity = 0.0;\n    this.m_force.setZero();\n    this.m_torque = 0.0;\n  }\n};\n\nBody.prototype.isActive = function() {\n  return this.m_activeFlag;\n};\n\n/**\n * Set the active state of the body. An inactive body is not simulated and\n * cannot be collided with or woken up. If you pass a flag of true, all fixtures\n * will be added to the broad-phase. If you pass a flag of false, all fixtures\n * will be removed from the broad-phase and all contacts will be destroyed.\n * Fixtures and joints are otherwise unaffected.\n * \n * You may continue to create/destroy fixtures and joints on inactive bodies.\n * Fixtures on an inactive body are implicitly inactive and will not participate\n * in collisions, ray-casts, or queries. Joints connected to an inactive body\n * are implicitly inactive. An inactive body is still owned by a World object\n * and remains\n */\nBody.prototype.setActive = function(flag) {\n  _ASSERT && common.assert(this.isWorldLocked() == false);\n\n  if (flag == this.m_activeFlag) {\n    return;\n  }\n\n  this.m_activeFlag = !!flag;\n\n  if (this.m_activeFlag) {\n    // Create all proxies.\n    var broadPhase = this.m_world.m_broadPhase;\n    for (var f = this.m_fixtureList; f; f = f.m_next) {\n      f.createProxies(broadPhase, this.m_xf);\n    }\n    // Contacts are created the next time step.\n\n  } else {\n    // Destroy all proxies.\n    var broadPhase = this.m_world.m_broadPhase;\n    for (var f = this.m_fixtureList; f; f = f.m_next) {\n      f.destroyProxies(broadPhase);\n    }\n\n    // Destroy the attached contacts.\n    var ce = this.m_contactList;\n    while (ce) {\n      var ce0 = ce;\n      ce = ce.next;\n      this.m_world.destroyContact(ce0.contact);\n    }\n    this.m_contactList = null;\n  }\n};\n\nBody.prototype.isFixedRotation = function() {\n  return this.m_fixedRotationFlag;\n};\n\n/**\n * Set this body to have fixed rotation. This causes the mass to be reset.\n */\nBody.prototype.setFixedRotation = function(flag) {\n  if (this.m_fixedRotationFlag == flag) {\n    return;\n  }\n\n  this.m_fixedRotationFlag = !!flag;\n\n  this.m_angularVelocity = 0.0;\n\n  this.resetMassData();\n};\n\n/**\n * Get the world transform for the body's origin.\n */\nBody.prototype.getTransform = function() {\n  return this.m_xf;\n};\n\n/**\n * Set the position of the body's origin and rotation. Manipulating a body's\n * transform may cause non-physical behavior. Note: contacts are updated on the\n * next call to World.step.\n * \n * @param position The world position of the body's local origin.\n * @param angle The world rotation in radians.\n */\nBody.prototype.setTransform = function(position, angle) {\n  _ASSERT && common.assert(this.isWorldLocked() == false);\n  if (this.isWorldLocked() == true) {\n    return;\n  }\n\n  this.m_xf.set(position, angle);\n  this.m_sweep.setTransform(this.m_xf);\n\n  var broadPhase = this.m_world.m_broadPhase;\n  for (var f = this.m_fixtureList; f; f = f.m_next) {\n    f.synchronize(broadPhase, this.m_xf, this.m_xf);\n  }\n};\n\nBody.prototype.synchronizeTransform = function() {\n  this.m_sweep.getTransform(this.m_xf, 1);\n};\n\n/**\n * Update fixtures in broad-phase.\n */\nBody.prototype.synchronizeFixtures = function() {\n  var xf = Transform.identity();\n\n  this.m_sweep.getTransform(xf, 0);\n\n  var broadPhase = this.m_world.m_broadPhase;\n  for (var f = this.m_fixtureList; f; f = f.m_next) {\n    f.synchronize(broadPhase, xf, this.m_xf);\n  }\n};\n\n/**\n * Used in TOI.\n */\nBody.prototype.advance = function(alpha) {\n  // Advance to the new safe time. This doesn't sync the broad-phase.\n  this.m_sweep.advance(alpha);\n  this.m_sweep.c.set(this.m_sweep.c0);\n  this.m_sweep.a = this.m_sweep.a0;\n  this.m_sweep.getTransform(this.m_xf, 1);\n};\n\n/**\n * Get the world position for the body's origin.\n */\nBody.prototype.getPosition = function() {\n  return this.m_xf.p;\n};\n\nBody.prototype.setPosition = function(p) {\n  this.setTransform(p, this.m_sweep.a);\n};\n\n/**\n * Get the current world rotation angle in radians.\n */\nBody.prototype.getAngle = function() {\n  return this.m_sweep.a;\n};\n\nBody.prototype.setAngle = function(angle) {\n  this.setTransform(this.m_xf.p, angle);\n};\n\n/**\n * Get the world position of the center of mass.\n */\nBody.prototype.getWorldCenter = function() {\n  return this.m_sweep.c;\n};\n\n/**\n * Get the local position of the center of mass.\n */\nBody.prototype.getLocalCenter = function() {\n  return this.m_sweep.localCenter;\n};\n\n/**\n * Get the linear velocity of the center of mass.\n * \n * @return the linear velocity of the center of mass.\n */\nBody.prototype.getLinearVelocity = function() {\n  return this.m_linearVelocity;\n};\n\n/**\n * Get the world linear velocity of a world point attached to this body.\n * \n * @param worldPoint A point in world coordinates.\n */\nBody.prototype.getLinearVelocityFromWorldPoint = function(worldPoint) {\n  var localCenter = Vec2.sub(worldPoint, this.m_sweep.c);\n  return Vec2.add(this.m_linearVelocity, Vec2.cross(this.m_angularVelocity,\n      localCenter));\n};\n\n/**\n * Get the world velocity of a local point.\n * \n * @param localPoint A point in local coordinates.\n */\nBody.prototype.getLinearVelocityFromLocalPoint = function(localPoint) {\n  return this.getLinearVelocityFromWorldPoint(this.getWorldPoint(localPoint));\n};\n\n/**\n * Set the linear velocity of the center of mass.\n * \n * @param v The new linear velocity of the center of mass.\n */\nBody.prototype.setLinearVelocity = function(v) {\n  if (this.m_type == staticBody) {\n    return;\n  }\n  if (Vec2.dot(v, v) > 0.0) {\n    this.setAwake(true);\n  }\n  this.m_linearVelocity.set(v);\n};\n\n/**\n * Get the angular velocity.\n * \n * @returns the angular velocity in radians/second.\n */\nBody.prototype.getAngularVelocity = function() {\n  return this.m_angularVelocity;\n};\n\n/**\n * Set the angular velocity.\n * \n * @param omega The new angular velocity in radians/second.\n */\nBody.prototype.setAngularVelocity = function(w) {\n  if (this.m_type == staticBody) {\n    return;\n  }\n  if (w * w > 0.0) {\n    this.setAwake(true);\n  }\n  this.m_angularVelocity = w;\n};\n\nBody.prototype.getLinearDamping = function() {\n  return this.m_linearDamping;\n};\n\nBody.prototype.setLinearDamping = function(linearDamping) {\n  this.m_linearDamping = linearDamping;\n};\n\nBody.prototype.getAngularDamping = function() {\n  return this.m_angularDamping;\n};\n\nBody.prototype.setAngularDamping = function(angularDamping) {\n  this.m_angularDamping = angularDamping;\n};\n\nBody.prototype.getGravityScale = function() {\n  return this.m_gravityScale;\n};\n\n/**\n * Scale the gravity applied to this body.\n */\nBody.prototype.setGravityScale = function(scale) {\n  this.m_gravityScale = scale;\n};\n\n/**\n * Get the total mass of the body.\n * \n * @returns The mass, usually in kilograms (kg).\n */\nBody.prototype.getMass = function() {\n  return this.m_mass;\n};\n\n/**\n * Get the rotational inertia of the body about the local origin.\n * \n * @return the rotational inertia, usually in kg-m^2.\n */\nBody.prototype.getInertia = function() {\n  return this.m_I + this.m_mass\n      * Vec2.dot(this.m_sweep.localCenter, this.m_sweep.localCenter);\n};\n\n/**\n * @typedef {Object} MassData This holds the mass data computed for a shape.\n * \n * @prop mass The mass of the shape, usually in kilograms.\n * @prop center The position of the shape's centroid relative to the shape's\n *       origin.\n * @prop I The rotational inertia of the shape about the local origin.\n */\nfunction MassData() {\n  this.mass = 0;\n  this.center = Vec2.zero();\n  this.I = 0;\n};\n\n/**\n * Copy the mass data of the body to data.\n */\nBody.prototype.getMassData = function(data) {\n  data.mass = this.m_mass;\n  data.I = this.getInertia();\n  data.center.set(this.m_sweep.localCenter);\n};\n\n/**\n * This resets the mass properties to the sum of the mass properties of the\n * fixtures. This normally does not need to be called unless you called\n * SetMassData to override the mass and you later want to reset the mass.\n */\nBody.prototype.resetMassData = function() {\n  // Compute mass data from shapes. Each shape has its own density.\n  this.m_mass = 0.0;\n  this.m_invMass = 0.0;\n  this.m_I = 0.0;\n  this.m_invI = 0.0;\n  this.m_sweep.localCenter.setZero();\n\n  // Static and kinematic bodies have zero mass.\n  if (this.isStatic() || this.isKinematic()) {\n    this.m_sweep.c0.set(this.m_xf.p);\n    this.m_sweep.c.set(this.m_xf.p);\n    this.m_sweep.a0 = this.m_sweep.a;\n    return;\n  }\n\n  _ASSERT && common.assert(this.isDynamic());\n\n  // Accumulate mass over all fixtures.\n  var localCenter = Vec2.zero();\n  for (var f = this.m_fixtureList; f; f = f.m_next) {\n    if (f.m_density == 0.0) {\n      continue;\n    }\n\n    var massData = new MassData();\n    f.getMassData(massData);\n    this.m_mass += massData.mass;\n    localCenter.addMul(massData.mass, massData.center);\n    this.m_I += massData.I;\n  }\n\n  // Compute center of mass.\n  if (this.m_mass > 0.0) {\n    this.m_invMass = 1.0 / this.m_mass;\n    localCenter.mul(this.m_invMass);\n\n  } else {\n    // Force all dynamic bodies to have a positive mass.\n    this.m_mass = 1.0;\n    this.m_invMass = 1.0;\n  }\n\n  if (this.m_I > 0.0 && this.m_fixedRotationFlag == false) {\n    // Center the inertia about the center of mass.\n    this.m_I -= this.m_mass * Vec2.dot(localCenter, localCenter);\n    _ASSERT && common.assert(this.m_I > 0.0);\n    this.m_invI = 1.0 / this.m_I;\n\n  } else {\n    this.m_I = 0.0;\n    this.m_invI = 0.0;\n  }\n\n  // Move center of mass.\n  var oldCenter = Vec2.clone(this.m_sweep.c);\n  this.m_sweep.setLocalCenter(localCenter, this.m_xf);\n\n  // Update center of mass velocity.\n  this.m_linearVelocity.add(Vec2.cross(this.m_angularVelocity, Vec2.sub(\n      this.m_sweep.c, oldCenter)));\n};\n\n/**\n * Set the mass properties to override the mass properties of the fixtures. Note\n * that this changes the center of mass position. Note that creating or\n * destroying fixtures can also alter the mass. This function has no effect if\n * the body isn't dynamic.\n * \n * @param massData The mass properties.\n */\nBody.prototype.setMassData = function(massData) {\n  _ASSERT && common.assert(this.isWorldLocked() == false);\n  if (this.isWorldLocked() == true) {\n    return;\n  }\n\n  if (this.m_type != dynamicBody) {\n    return;\n  }\n\n  this.m_invMass = 0.0;\n  this.m_I = 0.0;\n  this.m_invI = 0.0;\n\n  this.m_mass = massData.mass;\n  if (this.m_mass <= 0.0) {\n    this.m_mass = 1.0;\n  }\n\n  this.m_invMass = 1.0 / this.m_mass;\n\n  if (massData.I > 0.0 && this.m_fixedRotationFlag == false) {\n    this.m_I = massData.I - this.m_mass\n        * Vec2.dot(massData.center, massData.center);\n    _ASSERT && common.assert(this.m_I > 0.0);\n    this.m_invI = 1.0 / this.m_I;\n  }\n\n  // Move center of mass.\n  var oldCenter = Vec2.clone(this.m_sweep.c);\n  this.m_sweep.setLocalCenter(massData.center, this.m_xf);\n\n  // Update center of mass velocity.\n  this.m_linearVelocity.add(Vec2.cross(this.m_angularVelocity, Vec2.sub(\n      this.m_sweep.c, oldCenter)));\n};\n\n/**\n * Apply a force at a world point. If the force is not applied at the center of\n * mass, it will generate a torque and affect the angular velocity. This wakes\n * up the body.\n * \n * @param force The world force vector, usually in Newtons (N).\n * @param point The world position of the point of application.\n * @param wake Also wake up the body\n */\nBody.prototype.applyForce = function(force, point, wake) {\n  if (this.m_type != dynamicBody) {\n    return;\n  }\n  if (wake && this.m_awakeFlag == false) {\n    this.setAwake(true);\n  }\n  // Don't accumulate a force if the body is sleeping.\n  if (this.m_awakeFlag) {\n    this.m_force.add(force);\n    this.m_torque += Vec2.cross(Vec2.sub(point, this.m_sweep.c), force);\n  }\n};\n\n/**\n * Apply a force to the center of mass. This wakes up the body.\n * \n * @param force The world force vector, usually in Newtons (N).\n * @param wake Also wake up the body\n */\nBody.prototype.applyForceToCenter = function(force, wake) {\n  if (this.m_type != dynamicBody) {\n    return;\n  }\n  if (wake && this.m_awakeFlag == false) {\n    this.setAwake(true);\n  }\n  // Don't accumulate a force if the body is sleeping\n  if (this.m_awakeFlag) {\n    this.m_force.add(force);\n  }\n};\n\n/**\n * Apply a torque. This affects the angular velocity without affecting the\n * linear velocity of the center of mass. This wakes up the body.\n * \n * @param torque About the z-axis (out of the screen), usually in N-m.\n * @param wake Also wake up the body\n */\nBody.prototype.applyTorque = function(torque, wake) {\n  if (this.m_type != dynamicBody) {\n    return;\n  }\n  if (wake && this.m_awakeFlag == false) {\n    this.setAwake(true);\n  }\n  // Don't accumulate a force if the body is sleeping\n  if (this.m_awakeFlag) {\n    this.m_torque += torque;\n  }\n};\n\n/**\n * Apply an impulse at a point. This immediately modifies the velocity. It also\n * modifies the angular velocity if the point of application is not at the\n * center of mass. This wakes up the body.\n * \n * @param impulse The world impulse vector, usually in N-seconds or kg-m/s.\n * @param point The world position of the point of application.\n * @param wake Also wake up the body\n */\nBody.prototype.applyLinearImpulse = function(impulse, point, wake) {\n  if (this.m_type != dynamicBody) {\n    return;\n  }\n  if (wake && this.m_awakeFlag == false) {\n    this.setAwake(true);\n  }\n\n  // Don't accumulate velocity if the body is sleeping\n  if (this.m_awakeFlag) {\n    this.m_linearVelocity.addMul(this.m_invMass, impulse);\n    this.m_angularVelocity += this.m_invI * Vec2.cross(Vec2.sub(point, this.m_sweep.c), impulse);\n  }\n};\n\n/**\n * Apply an angular impulse.\n * \n * @param impulse The angular impulse in units of kg*m*m/s\n * @param wake Also wake up the body\n */\nBody.prototype.applyAngularImpulse = function(impulse, wake) {\n  if (this.m_type != dynamicBody) {\n    return;\n  }\n\n  if (wake && this.m_awakeFlag == false) {\n    this.setAwake(true);\n  }\n  // Don't accumulate velocity if the body is sleeping\n  if (this.m_awakeFlag) {\n    this.m_angularVelocity += this.m_invI * impulse;\n  }\n};\n\n/**\n * This is used to prevent connected bodies (by joints) from colliding,\n * depending on the joint's collideConnected flag.\n */\nBody.prototype.shouldCollide = function(that) {\n  // At least one body should be dynamic.\n  if (this.m_type != dynamicBody && that.m_type != dynamicBody) {\n    return false;\n  }\n  // Does a joint prevent collision?\n  for (var jn = this.m_jointList; jn; jn = jn.next) {\n    if (jn.other == that) {\n      if (jn.joint.m_collideConnected == false) {\n        return false;\n      }\n    }\n  }\n  return true;\n};\n\n/**\n * @internal Used for deserialize.\n */\nBody.prototype._addFixture = function(fixture) {\n  _ASSERT && common.assert(this.isWorldLocked() == false);\n\n  if (this.isWorldLocked() == true) {\n    return null;\n  }\n\n  if (this.m_activeFlag) {\n    var broadPhase = this.m_world.m_broadPhase;\n    fixture.createProxies(broadPhase, this.m_xf);\n  }\n\n  fixture.m_next = this.m_fixtureList;\n  this.m_fixtureList = fixture;\n\n  // Adjust mass properties if needed.\n  if (fixture.m_density > 0.0) {\n    this.resetMassData();\n  }\n\n  // Let the world know we have a new fixture. This will cause new contacts\n  // to be created at the beginning of the next time step.\n  this.m_world.m_newFixture = true;\n\n  return fixture\n};\n\n/**\n * Creates a fixture and attach it to this body.\n * \n * If the density is non-zero, this function automatically updates the mass of\n * the body.\n * \n * Contacts are not created until the next time step.\n * \n * Warning: This function is locked during callbacks.\n\n * @param {Shape|FixtureDef} shape Shape or fixture definition.\n * @param {FixtureDef|number} fixdef Fixture definition or just density.\n */\nBody.prototype.createFixture = function(shape, fixdef) {\n  _ASSERT && common.assert(this.isWorldLocked() == false);\n\n  if (this.isWorldLocked() == true) {\n    return null;\n  }\n\n  var fixture = new Fixture(this, shape, fixdef);\n  this._addFixture(fixture);\n  return fixture\n};\n\n/**\n * Destroy a fixture. This removes the fixture from the broad-phase and destroys\n * all contacts associated with this fixture. This will automatically adjust the\n * mass of the body if the body is dynamic and the fixture has positive density.\n * All fixtures attached to a body are implicitly destroyed when the body is\n * destroyed.\n * \n * Warning: This function is locked during callbacks.\n * \n * @param fixture The fixture to be removed.\n */\nBody.prototype.destroyFixture = function(fixture) {\n  _ASSERT && common.assert(this.isWorldLocked() == false);\n\n  if (this.isWorldLocked() == true) {\n    return;\n  }\n\n  _ASSERT && common.assert(fixture.m_body == this);\n\n  // Remove the fixture from this body's singly linked list.\n  var found = false;\n  if (this.m_fixtureList === fixture) {\n    this.m_fixtureList = fixture.m_next;\n    found = true;\n\n  } else {\n    var node = this.m_fixtureList;\n    while (node != null) {\n      if (node.m_next === fixture) {\n        node.m_next = fixture.m_next;\n        found = true;\n        break;\n      }\n      node = node.m_next;\n    }\n  }\n\n  // You tried to remove a shape that is not attached to this body.\n  _ASSERT && common.assert(found);\n\n  // Destroy any contacts associated with the fixture.\n  var edge = this.m_contactList;\n  while (edge) {\n    var c = edge.contact;\n    edge = edge.next;\n\n    var fixtureA = c.getFixtureA();\n    var fixtureB = c.getFixtureB();\n\n    if (fixture == fixtureA || fixture == fixtureB) {\n      // This destroys the contact and removes it from\n      // this body's contact list.\n      this.m_world.destroyContact(c);\n    }\n  }\n\n  if (this.m_activeFlag) {\n    var broadPhase = this.m_world.m_broadPhase;\n    fixture.destroyProxies(broadPhase);\n  }\n\n  fixture.m_body = null;\n  fixture.m_next = null;\n\n  this.m_world.publish('remove-fixture', fixture);\n\n  // Reset the mass data.\n  this.resetMassData();\n};\n\n/**\n * Get the corresponding world point of a local point.\n */\nBody.prototype.getWorldPoint = function(localPoint) {\n  return Transform.mulVec2(this.m_xf, localPoint);\n};\n\n/**\n * Get the corresponding world vector of a local vector.\n */\nBody.prototype.getWorldVector = function(localVector) {\n  return Rot.mulVec2(this.m_xf.q, localVector);\n};\n\n/**\n * Gets the corresponding local point of a world point.\n */\nBody.prototype.getLocalPoint = function(worldPoint) {\n  return Transform.mulTVec2(this.m_xf, worldPoint);\n};\n\n/**\n * \n * Gets the corresponding local vector of a world vector.\n */\nBody.prototype.getLocalVector = function(worldVector) {\n  return Rot.mulTVec2(this.m_xf.q, worldVector);\n};\n","/*\n * Planck.js\n * The MIT License\n * Copyright (c) 2021 Erin Catto, Ali Shakiba\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 all\n * 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 THE\n * SOFTWARE.\n */\n\nvar _DEBUG = typeof DEBUG === 'undefined' ? false : DEBUG;\nvar _ASSERT = typeof ASSERT === 'undefined' ? false : ASSERT;\n\nvar DEBUG_SOLVER = false;\n\nvar common = require('./util/common');\n\nvar Math = require('./common/Math');\nvar Vec2 = require('./common/Vec2');\nvar Transform = require('./common/Transform');\nvar Mat22 = require('./common/Mat22');\nvar Rot = require('./common/Rot');\n\nvar Settings = require('./Settings');\nvar Manifold = require('./Manifold');\nvar Distance = require('./collision/Distance');\n\nmodule.exports = Contact;\n\n/**\n * A contact edge is used to connect bodies and contacts together in a contact\n * graph where each body is a node and each contact is an edge. A contact edge\n * belongs to a doubly linked list maintained in each attached body. Each\n * contact has two contact nodes, one for each attached body.\n * \n * @prop {Contact} contact The contact\n * @prop {ContactEdge} prev The previous contact edge in the body's contact list\n * @prop {ContactEdge} next The next contact edge in the body's contact list\n * @prop {Body} other Provides quick access to the other body attached.\n */\nfunction ContactEdge(contact) {\n  this.contact = contact;\n  this.prev;\n  this.next;\n  this.other;\n};\n\n/**\n * @function Contact~evaluate\n * \n * @param manifold\n * @param xfA\n * @param fixtureA\n * @param indexA\n * @param xfB\n * @param fixtureB\n * @param indexB\n */\n\n/**\n * The class manages contact between two shapes. A contact exists for each\n * overlapping AABB in the broad-phase (except if filtered). Therefore a contact\n * object may exist that has no contact points.\n * \n * @param {Fixture} fA\n * @param {int} indexA\n * @param {Fixture} fB\n * @param {int} indexB\n * @param {Contact~evaluate} evaluateFcn\n */\nfunction Contact(fA, indexA, fB, indexB, evaluateFcn) {\n  // Nodes for connecting bodies.\n  this.m_nodeA = new ContactEdge(this);\n  this.m_nodeB = new ContactEdge(this);\n\n  this.m_fixtureA = fA;\n  this.m_fixtureB = fB;\n\n  this.m_indexA = indexA;\n  this.m_indexB = indexB;\n\n  this.m_evaluateFcn = evaluateFcn;\n\n  this.m_manifold = new Manifold();\n\n  this.m_prev = null;\n  this.m_next = null;\n\n  this.m_toi = 1.0;\n  this.m_toiCount = 0;\n  // This contact has a valid TOI in m_toi\n  this.m_toiFlag = false;\n\n  this.m_friction = mixFriction(this.m_fixtureA.m_friction,\n      this.m_fixtureB.m_friction);\n  this.m_restitution = mixRestitution(this.m_fixtureA.m_restitution,\n      this.m_fixtureB.m_restitution);\n\n  this.m_tangentSpeed = 0.0;\n\n  // This contact can be disabled (by user)\n  this.m_enabledFlag = true;\n\n  // Used when crawling contact graph when forming islands.\n  this.m_islandFlag = false;\n\n  // Set when the shapes are touching.\n  this.m_touchingFlag = false;\n\n  // This contact needs filtering because a fixture filter was changed.\n  this.m_filterFlag = false;\n\n  // This bullet contact had a TOI event\n  this.m_bulletHitFlag = false;\n\n  this.v_points = []; // VelocityConstraintPoint[maxManifoldPoints]\n  this.v_normal = Vec2.zero();\n  this.v_normalMass = new Mat22();\n  this.v_K = new Mat22();\n  this.v_pointCount;\n\n  this.v_tangentSpeed;\n  this.v_friction;\n  this.v_restitution;\n\n  this.v_invMassA;\n  this.v_invMassB;\n  this.v_invIA;\n  this.v_invIB;\n\n  this.p_localPoints = [] // Vec2[maxManifoldPoints];\n  this.p_localNormal = Vec2.zero();\n  this.p_localPoint = Vec2.zero();\n  this.p_localCenterA = Vec2.zero();\n  this.p_localCenterB = Vec2.zero();\n  this.p_type; // Manifold.Type\n  this.p_radiusA;\n  this.p_radiusB;\n  this.p_pointCount;\n\n  this.p_invMassA;\n  this.p_invMassB;\n  this.p_invIA;\n  this.p_invIB;\n}\n\nContact.prototype.initConstraint = function(step) {\n  var fixtureA = this.m_fixtureA;\n  var fixtureB = this.m_fixtureB;\n\n  var shapeA = fixtureA.getShape();\n  var shapeB = fixtureB.getShape();\n\n  var bodyA = fixtureA.getBody();\n  var bodyB = fixtureB.getBody();\n\n  var manifold = this.getManifold();\n\n  var pointCount = manifold.pointCount;\n  _ASSERT && common.assert(pointCount > 0);\n\n  this.v_invMassA = bodyA.m_invMass;\n  this.v_invMassB = bodyB.m_invMass;\n  this.v_invIA = bodyA.m_invI;\n  this.v_invIB = bodyB.m_invI;\n\n  this.v_friction = this.m_friction;\n  this.v_restitution = this.m_restitution;\n  this.v_tangentSpeed = this.m_tangentSpeed;\n\n  this.v_pointCount = pointCount;\n\n  this.v_K.setZero();\n  this.v_normalMass.setZero();\n\n  this.p_invMassA = bodyA.m_invMass;\n  this.p_invMassB = bodyB.m_invMass;\n  this.p_invIA = bodyA.m_invI;\n  this.p_invIB = bodyB.m_invI;\n  this.p_localCenterA = Vec2.clone(bodyA.m_sweep.localCenter);\n  this.p_localCenterB = Vec2.clone(bodyB.m_sweep.localCenter);\n\n  this.p_radiusA = shapeA.m_radius;\n  this.p_radiusB = shapeB.m_radius;\n\n  this.p_type = manifold.type;\n  this.p_localNormal = Vec2.clone(manifold.localNormal);\n  this.p_localPoint = Vec2.clone(manifold.localPoint);\n  this.p_pointCount = pointCount;\n\n  for (var j = 0; j < pointCount; ++j) {\n    var cp = manifold.points[j]; // ManifoldPoint\n    var vcp = this.v_points[j] = new VelocityConstraintPoint();\n\n    if (step.warmStarting) {\n      vcp.normalImpulse = step.dtRatio * cp.normalImpulse;\n      vcp.tangentImpulse = step.dtRatio * cp.tangentImpulse;\n\n    } else {\n      vcp.normalImpulse = 0.0;\n      vcp.tangentImpulse = 0.0;\n    }\n\n    vcp.rA.setZero();\n    vcp.rB.setZero();\n    vcp.normalMass = 0.0;\n    vcp.tangentMass = 0.0;\n    vcp.velocityBias = 0.0;\n\n    this.p_localPoints[j] = Vec2.clone(cp.localPoint);\n\n  }\n};\n\n/**\n * Get the contact manifold. Do not modify the manifold unless you understand\n * the internals of the library.\n */\nContact.prototype.getManifold = function() {\n  return this.m_manifold;\n}\n\n/**\n * Get the world manifold.\n * \n * @param {WorldManifold} [worldManifold]\n */\nContact.prototype.getWorldManifold = function(worldManifold) {\n  var bodyA = this.m_fixtureA.getBody();\n  var bodyB = this.m_fixtureB.getBody();\n  var shapeA = this.m_fixtureA.getShape();\n  var shapeB = this.m_fixtureB.getShape();\n\n  return this.m_manifold.getWorldManifold(worldManifold, bodyA.getTransform(),\n      shapeA.m_radius, bodyB.getTransform(), shapeB.m_radius);\n}\n\n/**\n * Enable/disable this contact. This can be used inside the pre-solve contact\n * listener. The contact is only disabled for the current time step (or sub-step\n * in continuous collisions).\n */\nContact.prototype.setEnabled = function(flag) {\n  this.m_enabledFlag = !!flag;\n}\n\n/**\n * Has this contact been disabled?\n */\nContact.prototype.isEnabled = function() {\n  return this.m_enabledFlag;\n}\n\n/**\n * Is this contact touching?\n */\nContact.prototype.isTouching = function() {\n  return this.m_touchingFlag;\n}\n\n/**\n * Get the next contact in the world's contact list.\n */\nContact.prototype.getNext = function() {\n  return this.m_next;\n}\n\n/**\n * Get fixture A in this contact.\n */\nContact.prototype.getFixtureA = function() {\n  return this.m_fixtureA;\n}\n\n/**\n * Get fixture B in this contact.\n */\nContact.prototype.getFixtureB = function() {\n  return this.m_fixtureB;\n}\n\n/**\n * Get the child primitive index for fixture A.\n */\nContact.prototype.getChildIndexA = function() {\n  return this.m_indexA;\n}\n\n/**\n * Get the child primitive index for fixture B.\n */\nContact.prototype.getChildIndexB = function() {\n  return this.m_indexB;\n}\n\n/**\n * Flag this contact for filtering. Filtering will occur the next time step.\n */\nContact.prototype.flagForFiltering = function() {\n  this.m_filterFlag = true;\n}\n\n/**\n * Override the default friction mixture. You can call this in\n * ContactListener.preSolve. This value persists until set or reset.\n */\nContact.prototype.setFriction = function(friction) {\n  this.m_friction = friction;\n}\n\n/**\n * Get the friction.\n */\nContact.prototype.getFriction = function() {\n  return this.m_friction;\n}\n\n/**\n * Reset the friction mixture to the default value.\n */\nContact.prototype.resetFriction = function() {\n  this.m_friction = mixFriction(this.m_fixtureA.m_friction,\n      this.m_fixtureB.m_friction);\n}\n\n/**\n * Override the default restitution mixture. You can call this in\n * ContactListener.preSolve. The value persists until you set or reset.\n */\nContact.prototype.setRestitution = function(restitution) {\n  this.m_restitution = restitution;\n}\n\n/**\n * Get the restitution.\n */\nContact.prototype.getRestitution = function() {\n  return this.m_restitution;\n}\n\n/**\n * Reset the restitution to the default value.\n */\nContact.prototype.resetRestitution = function() {\n  this.m_restitution = mixRestitution(this.m_fixtureA.m_restitution,\n      this.m_fixtureB.m_restitution);\n}\n\n/**\n * Set the desired tangent speed for a conveyor belt behavior. In meters per\n * second.\n */\nContact.prototype.setTangentSpeed = function(speed) {\n  this.m_tangentSpeed = speed;\n}\n\n/**\n * Get the desired tangent speed. In meters per second.\n */\nContact.prototype.getTangentSpeed = function() {\n  return this.m_tangentSpeed;\n}\n\n/**\n * Called by Update method, and implemented by subclasses.\n */\nContact.prototype.evaluate = function(manifold, xfA, xfB) {\n  this.m_evaluateFcn(manifold, xfA, this.m_fixtureA, this.m_indexA, xfB,\n      this.m_fixtureB, this.m_indexB);\n};\n\n/**\n * Updates the contact manifold and touching status.\n * \n * Note: do not assume the fixture AABBs are overlapping or are valid.\n * \n * @param {function} listener.beginContact\n * @param {function} listener.endContact\n * @param {function} listener.preSolve\n */\nContact.prototype.update = function(listener) {\n\n  // Re-enable this contact.\n  this.m_enabledFlag = true;\n\n  var touching = false;\n  var wasTouching = this.m_touchingFlag;\n\n  var sensorA = this.m_fixtureA.isSensor();\n  var sensorB = this.m_fixtureB.isSensor();\n  var sensor = sensorA || sensorB;\n\n  var bodyA = this.m_fixtureA.getBody();\n  var bodyB = this.m_fixtureB.getBody();\n  var xfA = bodyA.getTransform();\n  var xfB = bodyB.getTransform();\n\n  // Is this contact a sensor?\n  if (sensor) {\n    var shapeA = this.m_fixtureA.getShape();\n    var shapeB = this.m_fixtureB.getShape();\n    touching = Distance.testOverlap(shapeA, this.m_indexA, shapeB,\n        this.m_indexB, xfA, xfB);\n\n    // Sensors don't generate manifolds.\n    this.m_manifold.pointCount = 0;\n  } else {\n\n    // TODO reuse manifold\n    var oldManifold = this.m_manifold;\n    this.m_manifold = new Manifold();\n\n    this.evaluate(this.m_manifold, xfA, xfB);\n    touching = this.m_manifold.pointCount > 0;\n\n    // Match old contact ids to new contact ids and copy the\n    // stored impulses to warm start the solver.\n    for (var i = 0; i < this.m_manifold.pointCount; ++i) {\n      var nmp = this.m_manifold.points[i];\n      nmp.normalImpulse = 0.0;\n      nmp.tangentImpulse = 0.0;\n\n      for (var j = 0; j < oldManifold.pointCount; ++j) {\n        var omp = oldManifold.points[j];\n        if (omp.id.key == nmp.id.key) { // ContactID.key\n          nmp.normalImpulse = omp.normalImpulse;\n          nmp.tangentImpulse = omp.tangentImpulse;\n          break;\n        }\n      }\n    }\n\n    if (touching != wasTouching) {\n      bodyA.setAwake(true);\n      bodyB.setAwake(true);\n    }\n  }\n\n  this.m_touchingFlag = touching;\n\n  if (wasTouching == false && touching == true && listener) {\n    listener.beginContact(this);\n  }\n\n  if (wasTouching == true && touching == false && listener) {\n    listener.endContact(this);\n  }\n\n  if (sensor == false && touching && listener) {\n    listener.preSolve(this, oldManifold);\n  }\n}\n\nContact.prototype.solvePositionConstraint = function(step) {\n  return this._solvePositionConstraint(step, false);\n}\n\nContact.prototype.solvePositionConstraintTOI = function(step, toiA, toiB) {\n  return this._solvePositionConstraint(step, true, toiA, toiB);\n}\n\nContact.prototype._solvePositionConstraint = function(step, toi, toiA, toiB) {\n\n  var fixtureA = this.m_fixtureA;\n  var fixtureB = this.m_fixtureB;\n\n  var bodyA = fixtureA.getBody();\n  var bodyB = fixtureB.getBody();\n\n  var velocityA = bodyA.c_velocity;\n  var velocityB = bodyB.c_velocity;\n  var positionA = bodyA.c_position;\n  var positionB = bodyB.c_position;\n\n  var localCenterA = Vec2.clone(this.p_localCenterA);\n  var localCenterB = Vec2.clone(this.p_localCenterB);\n\n  var mA = 0.0;\n  var iA = 0.0;\n  if (!toi || (bodyA == toiA || bodyA == toiB)) {\n    mA = this.p_invMassA;\n    iA = this.p_invIA;\n  }\n\n  var mB = 0.0;\n  var iB = 0.0;\n  if (!toi || (bodyB == toiA || bodyB == toiB)) {\n    mB = this.p_invMassB;\n    iB = this.p_invIB;\n  }\n\n  var cA = Vec2.clone(positionA.c);\n  var aA = positionA.a;\n\n  var cB = Vec2.clone(positionB.c);\n  var aB = positionB.a;\n\n  var minSeparation = 0.0;\n\n  // Solve normal constraints\n  for (var j = 0; j < this.p_pointCount; ++j) {\n    var xfA = Transform.identity();\n    var xfB = Transform.identity();\n    xfA.q.set(aA);\n    xfB.q.set(aB);\n    xfA.p = Vec2.sub(cA, Rot.mulVec2(xfA.q, localCenterA));\n    xfB.p = Vec2.sub(cB, Rot.mulVec2(xfB.q, localCenterB));\n\n    // PositionSolverManifold\n    var normal, point, separation;\n    switch (this.p_type) {\n    case Manifold.e_circles:\n      var pointA = Transform.mulVec2(xfA, this.p_localPoint);\n      var pointB = Transform.mulVec2(xfB, this.p_localPoints[0]);\n      normal = Vec2.sub(pointB, pointA);\n      normal.normalize();\n      point = Vec2.combine(0.5, pointA, 0.5, pointB);\n      separation = Vec2.dot(Vec2.sub(pointB, pointA), normal) - this.p_radiusA\n          - this.p_radiusB;\n      break;\n\n    case Manifold.e_faceA:\n      normal = Rot.mulVec2(xfA.q, this.p_localNormal);\n      var planePoint = Transform.mulVec2(xfA, this.p_localPoint);\n      var clipPoint = Transform.mulVec2(xfB, this.p_localPoints[j]);\n      separation = Vec2.dot(Vec2.sub(clipPoint, planePoint), normal)\n          - this.p_radiusA - this.p_radiusB;\n      point = clipPoint;\n      break;\n\n    case Manifold.e_faceB:\n      normal = Rot.mulVec2(xfB.q, this.p_localNormal);\n      var planePoint = Transform.mulVec2(xfB, this.p_localPoint);\n      var clipPoint = Transform.mulVec2(xfA, this.p_localPoints[j]);\n      separation = Vec2.dot(Vec2.sub(clipPoint, planePoint), normal)\n          - this.p_radiusA - this.p_radiusB;\n      point = clipPoint;\n\n      // Ensure normal points from A to B\n      normal.mul(-1);\n      break;\n    }\n\n    var rA = Vec2.sub(point, cA);\n    var rB = Vec2.sub(point, cB);\n\n    // Track max constraint error.\n    minSeparation = Math.min(minSeparation, separation);\n\n    var baumgarte = toi ? Settings.toiBaugarte : Settings.baumgarte;\n    var linearSlop = Settings.linearSlop;\n    var maxLinearCorrection = Settings.maxLinearCorrection;\n\n    // Prevent large corrections and allow slop.\n    var C = Math.clamp(baumgarte * (separation + linearSlop),\n        -maxLinearCorrection, 0.0);\n\n    // Compute the effective mass.\n    var rnA = Vec2.cross(rA, normal);\n    var rnB = Vec2.cross(rB, normal);\n    var K = mA + mB + iA * rnA * rnA + iB * rnB * rnB;\n\n    // Compute normal impulse\n    var impulse = K > 0.0 ? -C / K : 0.0;\n\n    var P = Vec2.mul(impulse, normal);\n\n    cA.subMul(mA, P);\n    aA -= iA * Vec2.cross(rA, P);\n\n    cB.addMul(mB, P);\n    aB += iB * Vec2.cross(rB, P);\n  }\n\n  positionA.c.set(cA);\n  positionA.a = aA;\n\n  positionB.c.set(cB);\n  positionB.a = aB;\n\n  return minSeparation;\n}\n\n// TODO merge with ManifoldPoint\nfunction VelocityConstraintPoint() {\n  this.rA = Vec2.zero();\n  this.rB = Vec2.zero();\n  this.normalImpulse = 0;\n  this.tangentImpulse = 0;\n  this.normalMass = 0;\n  this.tangentMass = 0;\n  this.velocityBias = 0;\n}\n\nContact.prototype.initVelocityConstraint = function(step) {\n  var fixtureA = this.m_fixtureA;\n  var fixtureB = this.m_fixtureB;\n\n  var bodyA = fixtureA.getBody();\n  var bodyB = fixtureB.getBody();\n\n  var velocityA = bodyA.c_velocity;\n  var velocityB = bodyB.c_velocity;\n\n  var positionA = bodyA.c_position;\n  var positionB = bodyB.c_position;\n\n  var radiusA = this.p_radiusA;\n  var radiusB = this.p_radiusB;\n  var manifold = this.getManifold();\n\n  var mA = this.v_invMassA;\n  var mB = this.v_invMassB;\n  var iA = this.v_invIA;\n  var iB = this.v_invIB;\n  var localCenterA = Vec2.clone(this.p_localCenterA);\n  var localCenterB = Vec2.clone(this.p_localCenterB);\n\n  var cA = Vec2.clone(positionA.c);\n  var aA = positionA.a;\n  var vA = Vec2.clone(velocityA.v);\n  var wA = velocityA.w;\n\n  var cB = Vec2.clone(positionB.c);\n  var aB = positionB.a;\n  var vB = Vec2.clone(velocityB.v);\n  var wB = velocityB.w;\n\n  _ASSERT && common.assert(manifold.pointCount > 0);\n\n  var xfA = Transform.identity();\n  var xfB = Transform.identity();\n  xfA.q.set(aA);\n  xfB.q.set(aB);\n  xfA.p.setCombine(1, cA, -1, Rot.mulVec2(xfA.q, localCenterA));\n  xfB.p.setCombine(1, cB, -1, Rot.mulVec2(xfB.q, localCenterB));\n\n  var worldManifold = manifold.getWorldManifold(null, xfA, radiusA, xfB, radiusB);\n\n  this.v_normal.set(worldManifold.normal);\n\n  for (var j = 0; j < this.v_pointCount; ++j) {\n    var vcp = this.v_points[j]; // VelocityConstraintPoint\n\n    vcp.rA.set(Vec2.sub(worldManifold.points[j], cA));\n    vcp.rB.set(Vec2.sub(worldManifold.points[j], cB));\n\n    var rnA = Vec2.cross(vcp.rA, this.v_normal);\n    var rnB = Vec2.cross(vcp.rB, this.v_normal);\n\n    var kNormal = mA + mB + iA * rnA * rnA + iB * rnB * rnB;\n\n    vcp.normalMass = kNormal > 0.0 ? 1.0 / kNormal : 0.0;\n\n    var tangent = Vec2.cross(this.v_normal, 1.0);\n\n    var rtA = Vec2.cross(vcp.rA, tangent);\n    var rtB = Vec2.cross(vcp.rB, tangent);\n\n    var kTangent = mA + mB + iA * rtA * rtA + iB * rtB * rtB;\n\n    vcp.tangentMass = kTangent > 0.0 ? 1.0 / kTangent : 0.0;\n\n    // Setup a velocity bias for restitution.\n    vcp.velocityBias = 0.0;\n    var vRel = Vec2.dot(this.v_normal, vB)\n        + Vec2.dot(this.v_normal, Vec2.cross(wB, vcp.rB))\n        - Vec2.dot(this.v_normal, vA)\n        - Vec2.dot(this.v_normal, Vec2.cross(wA, vcp.rA));\n    if (vRel < -Settings.velocityThreshold) {\n      vcp.velocityBias = -this.v_restitution * vRel;\n    }\n  }\n\n  // If we have two points, then prepare the block solver.\n  if (this.v_pointCount == 2 && step.blockSolve) {\n    var vcp1 = this.v_points[0]; // VelocityConstraintPoint\n    var vcp2 = this.v_points[1]; // VelocityConstraintPoint\n\n    var rn1A = Vec2.cross(vcp1.rA, this.v_normal);\n    var rn1B = Vec2.cross(vcp1.rB, this.v_normal);\n    var rn2A = Vec2.cross(vcp2.rA, this.v_normal);\n    var rn2B = Vec2.cross(vcp2.rB, this.v_normal);\n\n    var k11 = mA + mB + iA * rn1A * rn1A + iB * rn1B * rn1B;\n    var k22 = mA + mB + iA * rn2A * rn2A + iB * rn2B * rn2B;\n    var k12 = mA + mB + iA * rn1A * rn2A + iB * rn1B * rn2B;\n\n    // Ensure a reasonable condition number.\n    var k_maxConditionNumber = 1000.0;\n    if (k11 * k11 < k_maxConditionNumber * (k11 * k22 - k12 * k12)) {\n      // K is safe to invert.\n      this.v_K.ex.set(k11, k12);\n      this.v_K.ey.set(k12, k22);\n      this.v_normalMass.set(this.v_K.getInverse());\n    } else {\n      // The constraints are redundant, just use one.\n      // TODO_ERIN use deepest?\n      this.v_pointCount = 1;\n    }\n  }\n\n  positionA.c.set(cA);\n  positionA.a = aA;\n  velocityA.v.set(vA);\n  velocityA.w = wA;\n\n  positionB.c.set(cB);\n  positionB.a = aB;\n  velocityB.v.set(vB);\n  velocityB.w = wB;\n};\n\nContact.prototype.warmStartConstraint = function(step) {\n  var fixtureA = this.m_fixtureA;\n  var fixtureB = this.m_fixtureB;\n\n  var bodyA = fixtureA.getBody();\n  var bodyB = fixtureB.getBody();\n\n  var velocityA = bodyA.c_velocity;\n  var velocityB = bodyB.c_velocity;\n  var positionA = bodyA.c_position;\n  var positionB = bodyB.c_position;\n\n  var mA = this.v_invMassA;\n  var iA = this.v_invIA;\n  var mB = this.v_invMassB;\n  var iB = this.v_invIB;\n\n  var vA = Vec2.clone(velocityA.v);\n  var wA = velocityA.w;\n  var vB = Vec2.clone(velocityB.v);\n  var wB = velocityB.w;\n\n  var normal = this.v_normal;\n  var tangent = Vec2.cross(normal, 1.0);\n\n  for (var j = 0; j < this.v_pointCount; ++j) {\n    var vcp = this.v_points[j]; // VelocityConstraintPoint\n\n    var P = Vec2.combine(vcp.normalImpulse, normal, vcp.tangentImpulse, tangent);\n    wA -= iA * Vec2.cross(vcp.rA, P);\n    vA.subMul(mA, P);\n    wB += iB * Vec2.cross(vcp.rB, P);\n    vB.addMul(mB, P);\n  }\n\n  velocityA.v.set(vA);\n  velocityA.w = wA;\n  velocityB.v.set(vB);\n  velocityB.w = wB;\n};\n\nContact.prototype.storeConstraintImpulses = function(step) {\n  var manifold = this.m_manifold;\n  for (var j = 0; j < this.v_pointCount; ++j) {\n    manifold.points[j].normalImpulse = this.v_points[j].normalImpulse;\n    manifold.points[j].tangentImpulse = this.v_points[j].tangentImpulse;\n  }\n};\n\nContact.prototype.solveVelocityConstraint = function(step) {\n  var bodyA = this.m_fixtureA.m_body;\n  var bodyB = this.m_fixtureB.m_body;\n\n  var velocityA = bodyA.c_velocity;\n  var positionA = bodyA.c_position;\n\n  var velocityB = bodyB.c_velocity;\n  var positionB = bodyB.c_position;\n\n  var mA = this.v_invMassA;\n  var iA = this.v_invIA;\n  var mB = this.v_invMassB;\n  var iB = this.v_invIB;\n\n  var vA = Vec2.clone(velocityA.v);\n  var wA = velocityA.w;\n  var vB = Vec2.clone(velocityB.v);\n  var wB = velocityB.w;\n\n  var normal = this.v_normal;\n  var tangent = Vec2.cross(normal, 1.0);\n  var friction = this.v_friction;\n\n  _ASSERT && common.assert(this.v_pointCount == 1 || this.v_pointCount == 2);\n\n  // Solve tangent constraints first because non-penetration is more important\n  // than friction.\n  for (var j = 0; j < this.v_pointCount; ++j) {\n    var vcp = this.v_points[j]; // VelocityConstraintPoint\n\n    // Relative velocity at contact\n    var dv = Vec2.zero();\n    dv.addCombine(1, vB, 1, Vec2.cross(wB, vcp.rB));\n    dv.subCombine(1, vA, 1, Vec2.cross(wA, vcp.rA));\n\n    // Compute tangent force\n    var vt = Vec2.dot(dv, tangent) - this.v_tangentSpeed;\n    var lambda = vcp.tangentMass * (-vt);\n\n    // Clamp the accumulated force\n    var maxFriction = friction * vcp.normalImpulse;\n    var newImpulse = Math.clamp(vcp.tangentImpulse + lambda, -maxFriction,\n        maxFriction);\n    lambda = newImpulse - vcp.tangentImpulse;\n    vcp.tangentImpulse = newImpulse;\n\n    // Apply contact impulse\n    var P = Vec2.mul(lambda, tangent);\n\n    vA.subMul(mA, P);\n    wA -= iA * Vec2.cross(vcp.rA, P);\n\n    vB.addMul(mB, P);\n    wB += iB * Vec2.cross(vcp.rB, P);\n  }\n\n  // Solve normal constraints\n  if (this.v_pointCount == 1 || step.blockSolve == false) {\n    for (var i = 0; i < this.v_pointCount; ++i) {\n      var vcp = this.v_points[i]; // VelocityConstraintPoint\n\n      // Relative velocity at contact\n      var dv = Vec2.zero();\n      dv.addCombine(1, vB, 1, Vec2.cross(wB, vcp.rB));\n      dv.subCombine(1, vA, 1, Vec2.cross(wA, vcp.rA));\n\n      // Compute normal impulse\n      var vn = Vec2.dot(dv, normal);\n      var lambda = -vcp.normalMass * (vn - vcp.velocityBias);\n\n      // Clamp the accumulated impulse\n      var newImpulse = Math.max(vcp.normalImpulse + lambda, 0.0);\n      lambda = newImpulse - vcp.normalImpulse;\n      vcp.normalImpulse = newImpulse;\n\n      // Apply contact impulse\n      var P = Vec2.mul(lambda, normal);\n\n      vA.subMul(mA, P);\n      wA -= iA * Vec2.cross(vcp.rA, P);\n\n      vB.addMul(mB, P);\n      wB += iB * Vec2.cross(vcp.rB, P);\n    }\n  } else {\n    // Block solver developed in collaboration with Dirk Gregorius (back in\n    // 01/07 on Box2D_Lite).\n    // Build the mini LCP for this contact patch\n    //\n    // vn = A * x + b, vn >= 0, , vn >= 0, x >= 0 and vn_i * x_i = 0 with i =\n    // 1..2\n    //\n    // A = J * W * JT and J = ( -n, -r1 x n, n, r2 x n )\n    // b = vn0 - velocityBias\n    //\n    // The system is solved using the \"Total enumeration method\" (s. Murty).\n    // The complementary constraint vn_i * x_i\n    // implies that we must have in any solution either vn_i = 0 or x_i = 0.\n    // So for the 2D contact problem the cases\n    // vn1 = 0 and vn2 = 0, x1 = 0 and x2 = 0, x1 = 0 and vn2 = 0, x2 = 0 and\n    // vn1 = 0 need to be tested. The first valid\n    // solution that satisfies the problem is chosen.\n    // \n    // In order to account of the accumulated impulse 'a' (because of the\n    // iterative nature of the solver which only requires\n    // that the accumulated impulse is clamped and not the incremental\n    // impulse) we change the impulse variable (x_i).\n    //\n    // Substitute:\n    // \n    // x = a + d\n    // \n    // a := old total impulse\n    // x := new total impulse\n    // d := incremental impulse\n    //\n    // For the current iteration we extend the formula for the incremental\n    // impulse\n    // to compute the new total impulse:\n    //\n    // vn = A * d + b\n    // = A * (x - a) + b\n    // = A * x + b - A * a\n    // = A * x + b'\n    // b' = b - A * a;\n\n    var vcp1 = this.v_points[0]; // VelocityConstraintPoint\n    var vcp2 = this.v_points[1]; // VelocityConstraintPoint\n\n    var a = Vec2.neo(vcp1.normalImpulse, vcp2.normalImpulse);\n    _ASSERT && common.assert(a.x >= 0.0 && a.y >= 0.0);\n\n    // Relative velocity at contact\n    var dv1 = Vec2.zero().add(vB).add(Vec2.cross(wB, vcp1.rB)).sub(vA).sub(Vec2.cross(wA, vcp1.rA));\n    var dv2 = Vec2.zero().add(vB).add(Vec2.cross(wB, vcp2.rB)).sub(vA).sub(Vec2.cross(wA, vcp2.rA));\n\n    // Compute normal velocity\n    var vn1 = Vec2.dot(dv1, normal);\n    var vn2 = Vec2.dot(dv2, normal);\n\n    var b = Vec2.neo(vn1 - vcp1.velocityBias, vn2 - vcp2.velocityBias);\n\n    // Compute b'\n    b.sub(Mat22.mulVec2(this.v_K, a));\n\n    var k_errorTol = 1e-3;\n    // NOT_USED(k_errorTol);\n\n    for (;;) {\n      //\n      // Case 1: vn = 0\n      //\n      // 0 = A * x + b'\n      //\n      // Solve for x:\n      //\n      // x = - inv(A) * b'\n      //\n      var x = Mat22.mulVec2(this.v_normalMass, b).neg();\n\n      if (x.x >= 0.0 && x.y >= 0.0) {\n        // Get the incremental impulse\n        var d = Vec2.sub(x, a);\n\n        // Apply incremental impulse\n        var P1 = Vec2.mul(d.x, normal);\n        var P2 = Vec2.mul(d.y, normal);\n\n        vA.subCombine(mA, P1, mA, P2);\n        wA -= iA * (Vec2.cross(vcp1.rA, P1) + Vec2.cross(vcp2.rA, P2));\n\n        vB.addCombine(mB, P1, mB, P2);\n        wB += iB * (Vec2.cross(vcp1.rB, P1) + Vec2.cross(vcp2.rB, P2));\n\n        // Accumulate\n        vcp1.normalImpulse = x.x;\n        vcp2.normalImpulse = x.y;\n\n        if (DEBUG_SOLVER) {\n          // Postconditions\n          dv1 = vB + Vec2.cross(wB, vcp1.rB) - vA - Vec2.cross(wA, vcp1.rA);\n          dv2 = vB + Vec2.cross(wB, vcp2.rB) - vA - Vec2.cross(wA, vcp2.rA);\n\n          // Compute normal velocity\n          vn1 = Dot(dv1, normal);\n          vn2 = Dot(dv2, normal);\n\n          _ASSERT && common.assert(Abs(vn1 - vcp1.velocityBias) < k_errorTol);\n          _ASSERT && common.assert(Abs(vn2 - vcp2.velocityBias) < k_errorTol);\n        }\n        break;\n      }\n\n      //\n      // Case 2: vn1 = 0 and x2 = 0\n      //\n      // 0 = a11 * x1 + a12 * 0 + b1'\n      // vn2 = a21 * x1 + a22 * 0 + b2'\n      //\n      x.x = -vcp1.normalMass * b.x;\n      x.y = 0.0;\n      vn1 = 0.0;\n      vn2 = this.v_K.ex.y * x.x + b.y;\n\n      if (x.x >= 0.0 && vn2 >= 0.0) {\n        // Get the incremental impulse\n        var d = Vec2.sub(x, a);\n\n        // Apply incremental impulse\n        var P1 = Vec2.mul(d.x, normal);\n        var P2 = Vec2.mul(d.y, normal);\n        vA.subCombine(mA, P1, mA, P2);\n        wA -= iA * (Vec2.cross(vcp1.rA, P1) + Vec2.cross(vcp2.rA, P2));\n\n        vB.addCombine(mB, P1, mB, P2);\n        wB += iB * (Vec2.cross(vcp1.rB, P1) + Vec2.cross(vcp2.rB, P2));\n\n        // Accumulate\n        vcp1.normalImpulse = x.x;\n        vcp2.normalImpulse = x.y;\n\n        if (DEBUG_SOLVER) {\n          // Postconditions\n          var dv1B = Vec2.add(vB, Vec2.cross(wB, vcp1.rB));\n          var dv1A = Vec2.add(vA, Vec2.cross(wA, vcp1.rA));\n          var dv1 = Vec2.sub(dv1B, dv1A);\n\n          // Compute normal velocity\n          vn1 = Vec2.dot(dv1, normal);\n\n          _ASSERT && common.assert(Math.abs(vn1 - vcp1.velocityBias) < k_errorTol);\n        }\n        break;\n      }\n\n      //\n      // Case 3: vn2 = 0 and x1 = 0\n      //\n      // vn1 = a11 * 0 + a12 * x2 + b1'\n      // 0 = a21 * 0 + a22 * x2 + b2'\n      //\n      x.x = 0.0;\n      x.y = -vcp2.normalMass * b.y;\n      vn1 = this.v_K.ey.x * x.y + b.x;\n      vn2 = 0.0;\n\n      if (x.y >= 0.0 && vn1 >= 0.0) {\n        // Resubstitute for the incremental impulse\n        var d = Vec2.sub(x, a);\n\n        // Apply incremental impulse\n        var P1 = Vec2.mul(d.x, normal);\n        var P2 = Vec2.mul(d.y, normal);\n        vA.subCombine(mA, P1, mA, P2);\n        wA -= iA * (Vec2.cross(vcp1.rA, P1) + Vec2.cross(vcp2.rA, P2));\n\n        vB.addCombine(mB, P1, mB, P2);\n        wB += iB * (Vec2.cross(vcp1.rB, P1) + Vec2.cross(vcp2.rB, P2));\n\n        // Accumulate\n        vcp1.normalImpulse = x.x;\n        vcp2.normalImpulse = x.y;\n\n        if (DEBUG_SOLVER) {\n          // Postconditions\n          var dv2B = Vec2.add(vB, Vec2.cross(wB, vcp2.rB));\n          var dv2A = Vec2.add(vA, Vec2.cross(wA, vcp2.rA));\n          var dv1 = Vec2.sub(dv2B, dv2A);\n\n          // Compute normal velocity\n          vn2 = Vec2.dot(dv2, normal);\n\n          _ASSERT && common.assert(Math.abs(vn2 - vcp2.velocityBias) < k_errorTol);\n        }\n        break;\n      }\n\n      //\n      // Case 4: x1 = 0 and x2 = 0\n      // \n      // vn1 = b1\n      // vn2 = b2;\n      //\n      x.x = 0.0;\n      x.y = 0.0;\n      vn1 = b.x;\n      vn2 = b.y;\n\n      if (vn1 >= 0.0 && vn2 >= 0.0) {\n        // Resubstitute for the incremental impulse\n        var d = Vec2.sub(x, a);\n\n        // Apply incremental impulse\n        var P1 = Vec2.mul(d.x, normal);\n        var P2 = Vec2.mul(d.y, normal);\n        vA.subCombine(mA, P1, mA, P2);\n        wA -= iA * (Vec2.cross(vcp1.rA, P1) + Vec2.cross(vcp2.rA, P2));\n\n        vB.addCombine(mB, P1, mB, P2);\n        wB += iB * (Vec2.cross(vcp1.rB, P1) + Vec2.cross(vcp2.rB, P2));\n\n        // Accumulate\n        vcp1.normalImpulse = x.x;\n        vcp2.normalImpulse = x.y;\n\n        break;\n      }\n\n      // No solution, give up. This is hit sometimes, but it doesn't seem to\n      // matter.\n      break;\n    }\n  }\n\n  velocityA.v.set(vA);\n  velocityA.w = wA;\n\n  velocityB.v.set(vB);\n  velocityB.w = wB;\n};\n\n/**\n * Friction mixing law. The idea is to allow either fixture to drive the\n * restitution to zero. For example, anything slides on ice.\n */\nfunction mixFriction(friction1, friction2) {\n  return Math.sqrt(friction1 * friction2);\n}\n\n/**\n * Restitution mixing law. The idea is allow for anything to bounce off an\n * inelastic surface. For example, a superball bounces on anything.\n */\nfunction mixRestitution(restitution1, restitution2) {\n  return restitution1 > restitution2 ? restitution1 : restitution2;\n}\n\nvar s_registers = [];\n\n/**\n * @param fn function(fixtureA, indexA, fixtureB, indexB) Contact\n */\nContact.addType = function(type1, type2, callback) {\n\n  s_registers[type1] = s_registers[type1] || {};\n  s_registers[type1][type2] = callback;\n}\n\nContact.create = function(fixtureA, indexA, fixtureB, indexB) {\n  var typeA = fixtureA.getType(); // Shape.Type\n  var typeB = fixtureB.getType(); // Shape.Type\n\n  // TODO: pool contacts\n  var contact, evaluateFcn;\n  if (evaluateFcn = s_registers[typeA] && s_registers[typeA][typeB]) {\n    contact = new Contact(fixtureA, indexA, fixtureB, indexB, evaluateFcn);\n  } else if (evaluateFcn = s_registers[typeB] && s_registers[typeB][typeA]) {\n    contact = new Contact(fixtureB, indexB, fixtureA, indexA, evaluateFcn);\n  } else {\n    return null;\n  }\n\n  // Contact creation may swap fixtures.\n  fixtureA = contact.getFixtureA();\n  fixtureB = contact.getFixtureB();\n  indexA = contact.getChildIndexA();\n  indexB = contact.getChildIndexB();\n  var bodyA = fixtureA.getBody();\n  var bodyB = fixtureB.getBody();\n\n  // Connect to body A\n  contact.m_nodeA.contact = contact;\n  contact.m_nodeA.other = bodyB;\n\n  contact.m_nodeA.prev = null;\n  contact.m_nodeA.next = bodyA.m_contactList;\n  if (bodyA.m_contactList != null) {\n    bodyA.m_contactList.prev = contact.m_nodeA;\n  }\n  bodyA.m_contactList = contact.m_nodeA;\n\n  // Connect to body B\n  contact.m_nodeB.contact = contact;\n  contact.m_nodeB.other = bodyA;\n\n  contact.m_nodeB.prev = null;\n  contact.m_nodeB.next = bodyB.m_contactList;\n  if (bodyB.m_contactList != null) {\n    bodyB.m_contactList.prev = contact.m_nodeB;\n  }\n  bodyB.m_contactList = contact.m_nodeB;\n\n  // Wake up the bodies\n  if (fixtureA.isSensor() == false && fixtureB.isSensor() == false) {\n    bodyA.setAwake(true);\n    bodyB.setAwake(true);\n  }\n\n  return contact;\n}\n\nContact.destroy = function(contact, listener) {\n  var fixtureA = contact.m_fixtureA;\n  var fixtureB = contact.m_fixtureB;\n\n  var bodyA = fixtureA.getBody();\n  var bodyB = fixtureB.getBody();\n\n  if (contact.isTouching()) {\n    listener.endContact(contact);\n  }\n\n  // Remove from body 1\n  if (contact.m_nodeA.prev) {\n    contact.m_nodeA.prev.next = contact.m_nodeA.next;\n  }\n\n  if (contact.m_nodeA.next) {\n    contact.m_nodeA.next.prev = contact.m_nodeA.prev;\n  }\n\n  if (contact.m_nodeA == bodyA.m_contactList) {\n    bodyA.m_contactList = contact.m_nodeA.next;\n  }\n\n  // Remove from body 2\n  if (contact.m_nodeB.prev) {\n    contact.m_nodeB.prev.next = contact.m_nodeB.next;\n  }\n\n  if (contact.m_nodeB.next) {\n    contact.m_nodeB.next.prev = contact.m_nodeB.prev;\n  }\n\n  if (contact.m_nodeB == bodyB.m_contactList) {\n    bodyB.m_contactList = contact.m_nodeB.next;\n  }\n\n  if (contact.m_manifold.pointCount > 0 && fixtureA.isSensor() == false\n      && fixtureB.isSensor() == false) {\n    bodyA.setAwake(true);\n    bodyB.setAwake(true);\n  }\n\n  var typeA = fixtureA.getType(); // Shape.Type\n  var typeB = fixtureB.getType(); // Shape.Type\n\n  var destroyFcn = s_registers[typeA][typeB].destroyFcn;\n  if (typeof destroyFcn === 'function') {\n    destroyFcn(contact);\n  }\n};\n","/*\n * Planck.js\n * The MIT License\n * Copyright (c) 2021 Erin Catto, Ali Shakiba\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 all\n * 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 THE\n * SOFTWARE.\n */\n\nvar _DEBUG = typeof DEBUG === 'undefined' ? false : DEBUG;\nvar _ASSERT = typeof ASSERT === 'undefined' ? false : ASSERT;\n\nmodule.exports = Fixture;\n\nvar common = require('./util/common');\nvar options = require('./util/options');\n\nvar Math = require('./common/Math');\nvar Vec2 = require('./common/Vec2');\n\nvar AABB = require('./collision/AABB');\n\nvar Shape = require('./Shape');\n\n/**\n * @typedef {Object} FixtureDef\n *\n * A fixture definition is used to create a fixture. This class defines an\n * abstract fixture definition. You can reuse fixture definitions safely.\n * \n * @prop friction The friction coefficient, usually in the range [0,1]\n * @prop restitution The restitution (elasticity) usually in the range [0,1]\n * @prop density The density, usually in kg/m^2\n * @prop isSensor A sensor shape collects contact information but never\n *       generates a collision response\n * @prop userData\n * @prop filterGroupIndex Zero, positive or negative collision group. Fixtures with same positive groupIndex always collide and fixtures with same\n * negative groupIndex never collide.\n * @prop filterCategoryBits Collision category bit or bits that this fixture belongs\n *       to. If groupIndex is zero or not matching, then at least one bit in this fixture\n * categoryBits should match other fixture maskBits and vice versa.\n * @prop filterMaskBits Collision category bit or bits that this fixture accept for\n *       collision.\n */\nvar FixtureDef = {\n  userData : null,\n  friction : 0.2,\n  restitution : 0.0,\n  density : 0.0,\n  isSensor : false,\n\n  filterGroupIndex : 0,\n  filterCategoryBits : 0x0001,\n  filterMaskBits : 0xFFFF\n};\n\n/**\n * This proxy is used internally to connect shape children to the broad-phase.\n */\nfunction FixtureProxy(fixture, childIndex) {\n  this.aabb = new AABB();\n  this.fixture = fixture;\n  this.childIndex = childIndex;\n  this.proxyId;\n};\n\n/**\n * A fixture is used to attach a shape to a body for collision detection. A\n * fixture inherits its transform from its parent. Fixtures hold additional\n * non-geometric data such as friction, collision filters, etc. Fixtures are\n * created via Body.createFixture.\n * \n * @param {Body} body\n * @param {Shape|FixtureDef} shape Shape of fixture definition.\n * @param {FixtureDef|number} def Fixture definition or number.\n */\nfunction Fixture(body, shape, def) {\n  if (shape.shape) {\n    def = shape;\n    shape = shape.shape;\n\n  } else if (typeof def === 'number') {\n    def = {density : def};\n  }\n\n  def = options(def, FixtureDef);\n\n  this.m_body = body;\n\n  this.m_friction = def.friction;\n  this.m_restitution = def.restitution;\n  this.m_density = def.density;\n  this.m_isSensor = def.isSensor;\n\n  this.m_filterGroupIndex = def.filterGroupIndex;\n  this.m_filterCategoryBits = def.filterCategoryBits;\n  this.m_filterMaskBits = def.filterMaskBits;\n\n  // TODO validate shape\n  this.m_shape = shape; //.clone();\n\n  this.m_next = null;\n\n  this.m_proxies = [];\n  this.m_proxyCount = 0;\n\n  var childCount = this.m_shape.getChildCount();\n  for (var i = 0; i < childCount; ++i) {\n    this.m_proxies[i] = new FixtureProxy(this, i);\n  }\n\n  this.m_userData = def.userData;\n};\n\n/**\n * Re-setup fixture.\n * @private\n */\nFixture.prototype._reset = function() {\n  var body = this.getBody();\n  var broadPhase = body.m_world.m_broadPhase;\n  this.destroyProxies(broadPhase);\n  if (this.m_shape._reset) {\n    this.m_shape._reset();\n  }\n  var childCount = this.m_shape.getChildCount();\n  for (var i = 0; i < childCount; ++i) {\n    this.m_proxies[i] = new FixtureProxy(this, i);\n  }\n  this.createProxies(broadPhase, body.m_xf);\n  body.resetMassData();\n};\n\nFixture.prototype._serialize = function() {\n  return {\n    friction: this.m_friction,\n    restitution: this.m_restitution,\n    density: this.m_density,\n    isSensor: this.m_isSensor,\n\n    filterGroupIndex: this.m_filterGroupIndex,\n    filterCategoryBits: this.m_filterCategoryBits,\n    filterMaskBits: this.m_filterMaskBits,\n\n    shape: this.m_shape,\n  };\n};\n\nFixture._deserialize = function(data, body, restore) {\n  var shape = restore(Shape, data.shape);\n  var fixture = shape && new Fixture(body, shape, data);\n  return fixture;\n};\n\n/**\n * Get the type of the child shape. You can use this to down cast to the\n * concrete shape.\n */\nFixture.prototype.getType = function() {\n  return this.m_shape.getType();\n}\n\n/**\n * Get the child shape. You can modify the child shape, however you should not\n * change the number of vertices because this will crash some collision caching\n * mechanisms. Manipulating the shape may lead to non-physical behavior.\n */\nFixture.prototype.getShape = function() {\n  return this.m_shape;\n}\n/**\n * A sensor shape collects contact information but never generates a collision\n * response.\n */\nFixture.prototype.isSensor = function() {\n  return this.m_isSensor;\n}\n\n/**\n * Set if this fixture is a sensor.\n */\nFixture.prototype.setSensor = function(sensor) {\n  if (sensor != this.m_isSensor) {\n    this.m_body.setAwake(true);\n    this.m_isSensor = sensor;\n  }\n}\n\n/**\n * Get the contact filtering data.\n */\n// Fixture.prototype.getFilterData = function() {\n//   return this.m_filter;\n// }\n\n/**\n * Get the user data that was assigned in the fixture definition. Use this to\n * store your application specific data.\n */\nFixture.prototype.getUserData = function() {\n  return this.m_userData;\n}\n\n/**\n * Set the user data. Use this to store your application specific data.\n */\nFixture.prototype.setUserData = function(data) {\n  this.m_userData = data;\n}\n\n/**\n * Get the parent body of this fixture. This is null if the fixture is not\n * attached.\n */\nFixture.prototype.getBody = function() {\n  return this.m_body;\n}\n\n/**\n * Get the next fixture in the parent body's fixture list.\n */\nFixture.prototype.getNext = function() {\n  return this.m_next;\n}\n\n/**\n * Get the density of this fixture.\n */\nFixture.prototype.getDensity = function() {\n  return this.m_density;\n}\n\n/**\n * Set the density of this fixture. This will _not_ automatically adjust the\n * mass of the body. You must call Body.resetMassData to update the body's mass.\n */\nFixture.prototype.setDensity = function(density) {\n  _ASSERT && common.assert(Math.isFinite(density) && density >= 0.0);\n  this.m_density = density;\n}\n\n/**\n * Get the coefficient of friction, usually in the range [0,1].\n */\nFixture.prototype.getFriction = function() {\n  return this.m_friction;\n}\n\n/**\n * Set the coefficient of friction. This will not change the friction of\n * existing contacts.\n */\nFixture.prototype.setFriction = function(friction) {\n  this.m_friction = friction;\n}\n\n/**\n * Get the coefficient of restitution.\n */\nFixture.prototype.getRestitution = function() {\n  return this.m_restitution;\n}\n\n/**\n * Set the coefficient of restitution. This will not change the restitution of\n * existing contacts.\n */\nFixture.prototype.setRestitution = function(restitution) {\n  this.m_restitution = restitution;\n}\n\n/**\n * Test a point in world coordinates for containment in this fixture.\n */\nFixture.prototype.testPoint = function(p) {\n  return this.m_shape.testPoint(this.m_body.getTransform(), p);\n}\n\n/**\n * Cast a ray against this shape.\n */\nFixture.prototype.rayCast = function(output, input, childIndex) {\n  return this.m_shape.rayCast(output, input, this.m_body.getTransform(), childIndex);\n}\n\n/**\n * Get the mass data for this fixture. The mass data is based on the density and\n * the shape. The rotational inertia is about the shape's origin. This operation\n * may be expensive.\n */\nFixture.prototype.getMassData = function(massData) {\n  this.m_shape.computeMass(massData, this.m_density);\n}\n\n/**\n * Get the fixture's AABB. This AABB may be enlarge and/or stale. If you need a\n * more accurate AABB, compute it using the shape and the body transform.\n */\nFixture.prototype.getAABB = function(childIndex) {\n  _ASSERT && common.assert(0 <= childIndex && childIndex < this.m_proxyCount);\n  return this.m_proxies[childIndex].aabb;\n}\n\n/**\n * These support body activation/deactivation.\n */\nFixture.prototype.createProxies = function(broadPhase, xf) {\n  _ASSERT && common.assert(this.m_proxyCount == 0);\n\n  // Create proxies in the broad-phase.\n  this.m_proxyCount = this.m_shape.getChildCount();\n\n  for (var i = 0; i < this.m_proxyCount; ++i) {\n    var proxy = this.m_proxies[i];\n    this.m_shape.computeAABB(proxy.aabb, xf, i);\n    proxy.proxyId = broadPhase.createProxy(proxy.aabb, proxy);\n  }\n}\n\nFixture.prototype.destroyProxies = function(broadPhase) {\n  // Destroy proxies in the broad-phase.\n  for (var i = 0; i < this.m_proxyCount; ++i) {\n    var proxy = this.m_proxies[i];\n    broadPhase.destroyProxy(proxy.proxyId);\n    proxy.proxyId = null;\n  }\n\n  this.m_proxyCount = 0;\n}\n\n/**\n * Updates this fixture proxy in broad-phase (with combined AABB of current and\n * next transformation).\n */\nFixture.prototype.synchronize = function(broadPhase, xf1, xf2) {\n  for (var i = 0; i < this.m_proxyCount; ++i) {\n    var proxy = this.m_proxies[i];\n    // Compute an AABB that covers the swept shape (may miss some rotation\n    // effect).\n    var aabb1 = new AABB();\n    var aabb2 = new AABB();\n    this.m_shape.computeAABB(aabb1, xf1, proxy.childIndex);\n    this.m_shape.computeAABB(aabb2, xf2, proxy.childIndex);\n\n    proxy.aabb.combine(aabb1, aabb2);\n\n    var displacement = Vec2.sub(xf2.p, xf1.p);\n\n    broadPhase.moveProxy(proxy.proxyId, proxy.aabb, displacement);\n  }\n}\n\n/**\n * Set the contact filtering data. This will not update contacts until the next\n * time step when either parent body is active and awake. This automatically\n * calls refilter.\n */\nFixture.prototype.setFilterData = function(filter) {\n  this.m_filterGroupIndex = filter.groupIndex;\n  this.m_filterCategoryBits = filter.categoryBits;\n  this.m_filterMaskBits = filter.maskBits;\n  this.refilter();\n}\n\nFixture.prototype.getFilterGroupIndex = function() {\n  return this.m_filterGroupIndex;\n}\n\nFixture.prototype.setFilterGroupIndex = function(groupIndex) {\n  return this.m_filterGroupIndex = groupIndex;\n}\n\nFixture.prototype.getFilterCategoryBits = function() {\n  return this.m_filterCategoryBits;\n}\n\nFixture.prototype.setFilterCategoryBits = function(categoryBits) {\n  this.m_filterCategoryBits = categoryBits;\n}\n\nFixture.prototype.getFilterMaskBits = function() {\n  return this.m_filterMaskBits;\n}\n\nFixture.prototype.setFilterMaskBits = function(maskBits) {\n  this.m_filterMaskBits = maskBits;\n}\n\n/**\n * Call this if you want to establish collision that was previously disabled by\n * ContactFilter.\n */\nFixture.prototype.refilter = function() {\n  if (this.m_body == null) {\n    return;\n  }\n\n  // Flag associated contacts for filtering.\n  var edge = this.m_body.getContactList();\n  while (edge) {\n    var contact = edge.contact;\n    var fixtureA = contact.getFixtureA();\n    var fixtureB = contact.getFixtureB();\n    if (fixtureA == this || fixtureB == this) {\n      contact.flagForFiltering();\n    }\n\n    edge = edge.next;\n  }\n\n  var world = this.m_body.getWorld();\n\n  if (world == null) {\n    return;\n  }\n\n  // Touch each proxy so that new pairs may be created\n  var broadPhase = world.m_broadPhase;\n  for (var i = 0; i < this.m_proxyCount; ++i) {\n    broadPhase.touchProxy(this.m_proxies[i].proxyId);\n  }\n}\n\n/**\n * Implement this method to provide collision filtering, if you want finer\n * control over contact creation.\n * \n * Return true if contact calculations should be performed between these two\n * fixtures.\n * \n * Warning: for performance reasons this is only called when the AABBs begin to\n * overlap.\n * \n * @param {Fixture} that\n */\nFixture.prototype.shouldCollide = function(that) {\n\n  if (that.m_filterGroupIndex === this.m_filterGroupIndex && that.m_filterGroupIndex !== 0) {\n    return that.m_filterGroupIndex > 0;\n  }\n\n  var collideA = (that.m_filterMaskBits & this.m_filterCategoryBits) !== 0;\n  var collideB = (that.m_filterCategoryBits & this.m_filterMaskBits) !== 0;\n  var collide = collideA && collideB;\n  return collide;\n}\n","/*\n * Planck.js\n * The MIT License\n * Copyright (c) 2021 Erin Catto, Ali Shakiba\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 all\n * 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 THE\n * SOFTWARE.\n */\n\nvar _DEBUG = typeof DEBUG === 'undefined' ? false : DEBUG;\nvar _ASSERT = typeof ASSERT === 'undefined' ? false : ASSERT;\n\nmodule.exports = Joint;\n\nvar common = require('./util/common');\n\n/**\n * A joint edge is used to connect bodies and joints together in a joint graph\n * where each body is a node and each joint is an edge. A joint edge belongs to\n * a doubly linked list maintained in each attached body. Each joint has two\n * joint nodes, one for each attached body.\n * \n * @prop {Body} other provides quick access to the other body attached.\n * @prop {Joint} joint the joint\n * @prop {JointEdge} prev the previous joint edge in the body's joint list\n * @prop {JointEdge} next the next joint edge in the body's joint list\n */\nfunction JointEdge() {\n  this.other = null;\n  this.joint = null;\n  this.prev = null;\n  this.next = null;\n};\n\n/**\n * @typedef {Object} JointDef\n *\n * Joint definitions are used to construct joints.\n * \n * @prop userData Use this to attach application specific data to your joints.\n *       void userData;\n * @prop {boolean} collideConnected Set this flag to true if the attached bodies\n *       should collide.\n *\n * @prop {Body} bodyA The first attached body.\n * @prop {Body} bodyB The second attached body.\n */\n\nvar DEFAULTS = {\n  userData : null,\n  collideConnected : false\n};\n\n/**\n * The base joint class. Joints are used to constraint two bodies together in\n * various fashions. Some joints also feature limits and motors.\n * \n * @param {JointDef} def\n */\nfunction Joint(def, bodyA, bodyB) {\n  bodyA = def.bodyA || bodyA;\n  bodyB = def.bodyB || bodyB;\n\n  _ASSERT && common.assert(bodyA);\n  _ASSERT && common.assert(bodyB);\n  _ASSERT && common.assert(bodyA != bodyB);\n\n  this.m_type = 'unknown-joint';\n\n  this.m_bodyA = bodyA;\n  this.m_bodyB = bodyB;\n\n  this.m_index = 0;\n  this.m_collideConnected = !!def.collideConnected;\n\n  this.m_prev = null;\n  this.m_next = null;\n\n  this.m_edgeA = new JointEdge();\n  this.m_edgeB = new JointEdge();\n\n  this.m_islandFlag = false;\n  this.m_userData = def.userData;\n};\n\nJoint.TYPES = {};\n\nJoint._deserialize = function(data, context, restore) {\n  var clazz = Joint.TYPES[data.type];\n  return clazz && restore(clazz, data);\n};\n\n/**\n * Short-cut function to determine if either body is inactive.\n * \n * @returns {boolean}\n */\nJoint.prototype.isActive = function() {\n  return this.m_bodyA.isActive() && this.m_bodyB.isActive();\n}\n\n/**\n * Get the type of the concrete joint.\n * \n * @returns JointType\n */\nJoint.prototype.getType = function() {\n  return this.m_type;\n}\n\n/**\n * Get the first body attached to this joint.\n * \n * @returns Body\n */\nJoint.prototype.getBodyA = function() {\n  return this.m_bodyA;\n}\n\n/**\n * Get the second body attached to this joint.\n * \n * @returns Body\n */\nJoint.prototype.getBodyB = function() {\n  return this.m_bodyB;\n}\n\n/**\n * Get the next joint the world joint list.\n * \n * @returns Joint\n */\nJoint.prototype.getNext = function() {\n  return this.m_next;\n}\n\nJoint.prototype.getUserData = function() {\n  return this.m_userData;\n}\n\nJoint.prototype.setUserData = function(data) {\n  this.m_userData = data;\n}\n\n/**\n * Get collide connected. Note: modifying the collide connect flag won't work\n * correctly because the flag is only checked when fixture AABBs begin to\n * overlap.\n * \n * @returns {boolean}\n */\nJoint.prototype.getCollideConnected = function() {\n  return this.m_collideConnected;\n};\n\n/**\n * Get the anchor point on bodyA in world coordinates.\n * \n * @return {Vec2}\n */\nJoint.prototype.getAnchorA = function() {\n};\n\n/**\n * Get the anchor point on bodyB in world coordinates.\n * \n * @return {Vec2}\n */\nJoint.prototype.getAnchorB = function() {\n};\n\n/**\n * Get the reaction force on bodyB at the joint anchor in Newtons.\n * \n * @param {float} inv_dt\n * @return {Vec2}\n */\nJoint.prototype.getReactionForce = function(inv_dt) {\n};\n\n/**\n * Get the reaction torque on bodyB in N*m.\n * \n * @param {float} inv_dt\n * @return {float}\n */\nJoint.prototype.getReactionTorque = function(inv_dt) {\n};\n\n/**\n * Shift the origin for any points stored in world coordinates.\n * \n * @param {Vec2} newOrigin\n */\nJoint.prototype.shiftOrigin = function(newOrigin) {\n};\n\n/**\n */\nJoint.prototype.initVelocityConstraints = function(step) {\n};\n\n/**\n */\nJoint.prototype.solveVelocityConstraints = function(step) {\n};\n\n/**\n * This returns true if the position errors are within tolerance.\n */\nJoint.prototype.solvePositionConstraints = function(step) {\n};\n","/*\n * Planck.js\n * The MIT License\n * Copyright (c) 2021 Erin Catto, Ali Shakiba\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 all\n * 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 THE\n * SOFTWARE.\n */\n\nvar _DEBUG = typeof DEBUG === 'undefined' ? false : DEBUG;\nvar _ASSERT = typeof ASSERT === 'undefined' ? false : ASSERT;\n\nvar common = require('./util/common');\n\nvar Vec2 = require('./common/Vec2');\nvar Transform = require('./common/Transform');\nvar Math = require('./common/Math');\nvar Rot = require('./common/Rot');\n\nmodule.exports = Manifold;\nmodule.exports.clipSegmentToLine = clipSegmentToLine;\nmodule.exports.clipVertex = ClipVertex;\nmodule.exports.getPointStates = getPointStates;\nmodule.exports.PointState = PointState;\n\n// Manifold Type\nManifold.e_circles = 0;\nManifold.e_faceA = 1;\nManifold.e_faceB = 2;\n\n// ContactFeature Type\nManifold.e_vertex = 0;\nManifold.e_face = 1;\n\n/**\n * A manifold for two touching convex shapes. Manifolds are created in `evaluate`\n * method of Contact subclasses.\n * \n * Supported manifold types are e_faceA or e_faceB for clip point versus plane\n * with radius and e_circles point versus point with radius.\n * \n * We store contacts in this way so that position correction can account for\n * movement, which is critical for continuous physics. All contact scenarios\n * must be expressed in one of these types. This structure is stored across time\n * steps, so we keep it small.\n * \n * @prop type e_circle, e_faceA, e_faceB\n * @prop localPoint Usage depends on manifold type:<br>\n *       e_circles: the local center of circleA <br>\n *       e_faceA: the center of faceA <br>\n *       e_faceB: the center of faceB\n * @prop localNormal Usage depends on manifold type:<br>\n *       e_circles: not used <br>\n *       e_faceA: the normal on polygonA <br>\n *       e_faceB: the normal on polygonB\n * @prop points The points of contact {ManifoldPoint[]}\n * @prop pointCount The number of manifold points\n */\nfunction Manifold() {\n  this.type;\n  this.localNormal = Vec2.zero();\n  this.localPoint = Vec2.zero();\n  this.points = [ new ManifoldPoint(), new ManifoldPoint() ];\n  this.pointCount = 0;\n};\n\n/**\n * A manifold point is a contact point belonging to a contact manifold. It holds\n * details related to the geometry and dynamics of the contact points.\n * \n * This structure is stored across time steps, so we keep it small.\n * \n * Note: impulses are used for internal caching and may not provide reliable\n * contact forces, especially for high speed collisions.\n * \n * @prop {Vec2} localPoint Usage depends on manifold type:<br>\n *       e_circles: the local center of circleB<br>\n *       e_faceA: the local center of cirlceB or the clip point of polygonB<br>\n *       e_faceB: the clip point of polygonA.\n * @prop normalImpulse The non-penetration impulse\n * @prop tangentImpulse The friction impulse\n * @prop {ContactID} id Uniquely identifies a contact point between two shapes\n *       to facilatate warm starting\n */\nfunction ManifoldPoint() {\n  this.localPoint = Vec2.zero();\n  this.normalImpulse = 0;\n  this.tangentImpulse = 0;\n  this.id = new ContactID();\n};\n\n/**\n * Contact ids to facilitate warm starting.\n * \n * @prop {ContactFeature} cf\n * @prop key Used to quickly compare contact ids.\n * \n */\nfunction ContactID() {\n  this.cf = new ContactFeature();\n};\n\nObject.defineProperty(ContactID.prototype, 'key', {\n  get: function() {\n    return this.cf.indexA + this.cf.indexB * 4 + this.cf.typeA * 16 + this.cf.typeB * 64;\n  },\n  enumerable: true,\n  configurable: true\n});\n\nContactID.prototype.set = function(o) {\n  // this.key = o.key;\n  this.cf.set(o.cf);\n};\n\n/**\n * The features that intersect to form the contact point.\n * \n * @prop indexA Feature index on shapeA\n * @prop indexB Feature index on shapeB\n * @prop typeA The feature type on shapeA\n * @prop typeB The feature type on shapeB\n */\nfunction ContactFeature() {\n  this.indexA;\n  this.indexB;\n  this.typeA;\n  this.typeB;\n};\n\nContactFeature.prototype.set = function(o) {\n  this.indexA = o.indexA;\n  this.indexB = o.indexB;\n  this.typeA = o.typeA;\n  this.typeB = o.typeB;\n};\n\n/**\n * This is used to compute the current state of a contact manifold.\n * \n * @prop normal World vector pointing from A to B\n * @prop points World contact point (point of intersection)\n * @prop separations A negative value indicates overlap, in meters\n */\nfunction WorldManifold() {\n  this.normal;\n  this.points = []; // [maxManifoldPoints]\n  this.separations = []; // float[maxManifoldPoints]\n};\n\n/**\n * Evaluate the manifold with supplied transforms. This assumes modest motion\n * from the original state. This does not change the point count, impulses, etc.\n * The radii must come from the shapes that generated the manifold.\n * \n * @param {WorldManifold} [wm]\n */\nManifold.prototype.getWorldManifold = function(wm, xfA, radiusA, xfB, radiusB) {\n  if (this.pointCount == 0) {\n    return;\n  }\n\n  wm = wm || new WorldManifold();\n\n  var normal = wm.normal;\n  var points = wm.points;\n  var separations = wm.separations;\n\n  // TODO: improve\n  switch (this.type) {\n  case Manifold.e_circles:\n    normal = Vec2.neo(1.0, 0.0);\n    var pointA = Transform.mulVec2(xfA, this.localPoint);\n    var pointB = Transform.mulVec2(xfB, this.points[0].localPoint);\n    var dist = Vec2.sub(pointB, pointA);\n    if (Vec2.lengthSquared(dist) > Math.EPSILON * Math.EPSILON) {\n      normal.set(dist);\n      normal.normalize();\n    }\n    var cA = pointA.clone().addMul(radiusA, normal);\n    var cB = pointB.clone().addMul(-radiusB, normal);\n    points[0] = Vec2.mid(cA, cB);\n    separations[0] = Vec2.dot(Vec2.sub(cB, cA), normal);\n    points.length = 1;\n    separations.length = 1;\n    break;\n\n  case Manifold.e_faceA:\n    normal = Rot.mulVec2(xfA.q, this.localNormal);\n    var planePoint = Transform.mulVec2(xfA, this.localPoint);\n\n    for (var i = 0; i < this.pointCount; ++i) {\n      var clipPoint = Transform.mulVec2(xfB, this.points[i].localPoint);\n      var cA = Vec2.clone(clipPoint).addMul(radiusA - Vec2.dot(Vec2.sub(clipPoint, planePoint), normal), normal);\n      var cB = Vec2.clone(clipPoint).subMul(radiusB, normal);\n      points[i] = Vec2.mid(cA, cB);\n      separations[i] = Vec2.dot(Vec2.sub(cB, cA), normal);\n    }\n    points.length = this.pointCount;\n    separations.length = this.pointCount;\n    break;\n\n  case Manifold.e_faceB:\n    normal = Rot.mulVec2(xfB.q, this.localNormal);\n    var planePoint = Transform.mulVec2(xfB, this.localPoint);\n\n    for (var i = 0; i < this.pointCount; ++i) {\n      var clipPoint = Transform.mulVec2(xfA, this.points[i].localPoint);\n      var cB = Vec2.combine(1, clipPoint, radiusB - Vec2.dot(Vec2.sub(clipPoint, planePoint), normal), normal);\n      var cA = Vec2.combine(1, clipPoint, -radiusA, normal);\n      points[i] = Vec2.mid(cA, cB);\n      separations[i] = Vec2.dot(Vec2.sub(cA, cB), normal);\n    }\n    points.length = this.pointCount;\n    separations.length = this.pointCount;\n    // Ensure normal points from A to B.\n    normal.mul(-1);\n    break;\n  }\n\n  wm.normal = normal;\n  wm.points = points;\n  wm.separations = separations;\n  return wm;\n}\n\n/**\n * This is used for determining the state of contact points.\n * \n * @prop {0} nullState Point does not exist\n * @prop {1} addState Point was added in the update\n * @prop {2} persistState Point persisted across the update\n * @prop {3} removeState Point was removed in the update\n */\nvar PointState = {\n  // TODO: use constants\n  nullState : 0,\n  addState : 1,\n  persistState : 2,\n  removeState : 3\n};\n\n/**\n * Compute the point states given two manifolds. The states pertain to the\n * transition from manifold1 to manifold2. So state1 is either persist or remove\n * while state2 is either add or persist.\n * \n * @param {PointState[Settings.maxManifoldPoints]} state1\n * @param {PointState[Settings.maxManifoldPoints]} state2\n */\nfunction getPointStates(state1, state2, manifold1, manifold2) {\n  // for (var i = 0; i < Settings.maxManifoldPoints; ++i) {\n  // state1[i] = PointState.nullState;\n  // state2[i] = PointState.nullState;\n  // }\n\n  // Detect persists and removes.\n  for (var i = 0; i < manifold1.pointCount; ++i) {\n    var id = manifold1.points[i].id;// ContactID\n\n    state1[i] = PointState.removeState;\n\n    for (var j = 0; j < manifold2.pointCount; ++j) {\n      if (manifold2.points[j].id.key == id.key) {\n        state1[i] = PointState.persistState;\n        break;\n      }\n    }\n  }\n\n  // Detect persists and adds.\n  for (var i = 0; i < manifold2.pointCount; ++i) {\n    var id = manifold2.points[i].id;// ContactID\n\n    state2[i] = PointState.addState;\n\n    for (var j = 0; j < manifold1.pointCount; ++j) {\n      if (manifold1.points[j].id.key == id.key) {\n        state2[i] = PointState.persistState;\n        break;\n      }\n    }\n  }\n}\n\n/**\n * Used for computing contact manifolds.\n * \n * @prop {Vec2} v\n * @prop {ContactID} id\n */\nfunction ClipVertex() {\n  this.v = Vec2.zero();\n  this.id = new ContactID();\n};\n\nClipVertex.prototype.set = function(o) {\n  this.v.set(o.v);\n  this.id.set(o.id);\n};\n\n/**\n * Clipping for contact manifolds. Sutherland-Hodgman clipping.\n * \n * @param {ClipVertex[2]} vOut\n * @param {ClipVertex[2]} vIn\n */\nfunction clipSegmentToLine(vOut, vIn, normal, offset, vertexIndexA) {\n  // Start with no output points\n  var numOut = 0;\n\n  // Calculate the distance of end points to the line\n  var distance0 = Vec2.dot(normal, vIn[0].v) - offset;\n  var distance1 = Vec2.dot(normal, vIn[1].v) - offset;\n\n  // If the points are behind the plane\n  if (distance0 <= 0.0)\n    vOut[numOut++].set(vIn[0]);\n  if (distance1 <= 0.0)\n    vOut[numOut++].set(vIn[1]);\n\n  // If the points are on different sides of the plane\n  if (distance0 * distance1 < 0.0) {\n    // Find intersection point of edge and plane\n    var interp = distance0 / (distance0 - distance1);\n    vOut[numOut].v.setCombine(1 - interp, vIn[0].v, interp, vIn[1].v);\n\n    // VertexA is hitting edgeB.\n    vOut[numOut].id.cf.indexA = vertexIndexA;\n    vOut[numOut].id.cf.indexB = vIn[0].id.cf.indexB;\n    vOut[numOut].id.cf.typeA = Manifold.e_vertex;\n    vOut[numOut].id.cf.typeB = Manifold.e_face;\n    ++numOut;\n  }\n\n  return numOut;\n}\n","/*\n * Planck.js\n * The MIT License\n * Copyright (c) 2021 Erin Catto, Ali Shakiba\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 all\n * 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 THE\n * SOFTWARE.\n */\n\nvar _DEBUG = typeof DEBUG === 'undefined' ? false : DEBUG;\nvar _ASSERT = typeof ASSERT === 'undefined' ? false : ASSERT;\n\n// TODO merge with World options?\n\nvar Settings = exports;\n\n/**\n * Tuning constants based on meters-kilograms-seconds (MKS) units.\n */\n\n// Collision\n/**\n * The maximum number of contact points between two convex shapes. Do not change\n * this value.\n */\nSettings.maxManifoldPoints = 2;\n\n/**\n * The maximum number of vertices on a convex polygon. You cannot increase this\n * too much because BlockAllocator has a maximum object size.\n */\nSettings.maxPolygonVertices = 12;\n\n/**\n * This is used to fatten AABBs in the dynamic tree. This allows proxies to move\n * by a small amount without triggering a tree adjustment. This is in meters.\n */\nSettings.aabbExtension = 0.1;\n\n/**\n * This is used to fatten AABBs in the dynamic tree. This is used to predict the\n * future position based on the current displacement. This is a dimensionless\n * multiplier.\n */\nSettings.aabbMultiplier = 2.0;\n\n/**\n * A small length used as a collision and constraint tolerance. Usually it is\n * chosen to be numerically significant, but visually insignificant.\n */\nSettings.linearSlop = 0.005;\nSettings.linearSlopSquared = Settings.linearSlop * Settings.linearSlop;\n\n/**\n * A small angle used as a collision and constraint tolerance. Usually it is\n * chosen to be numerically significant, but visually insignificant.\n */\nSettings.angularSlop = (2.0 / 180.0 * Math.PI);\n\n/**\n * The radius of the polygon/edge shape skin. This should not be modified.\n * Making this smaller means polygons will have an insufficient buffer for\n * continuous collision. Making it larger may create artifacts for vertex\n * collision.\n */\nSettings.polygonRadius = (2.0 * Settings.linearSlop);\n\n/**\n * Maximum number of sub-steps per contact in continuous physics simulation.\n */\nSettings.maxSubSteps = 8;\n\n// Dynamics\n\n/**\n * Maximum number of contacts to be handled to solve a TOI impact.\n */\nSettings.maxTOIContacts = 32;\n\n/**\n * Maximum iterations to solve a TOI.\n */\nSettings.maxTOIIterations = 20;\n\n/**\n * Maximum iterations to find Distance.\n */\nSettings.maxDistnceIterations = 20;\n\n/**\n * A velocity threshold for elastic collisions. Any collision with a relative\n * linear velocity below this threshold will be treated as inelastic.\n */\nSettings.velocityThreshold = 1.0;\n\n/**\n * The maximum linear position correction used when solving constraints. This\n * helps to prevent overshoot.\n */\nSettings.maxLinearCorrection = 0.2;\n\n/**\n * The maximum angular position correction used when solving constraints. This\n * helps to prevent overshoot.\n */\nSettings.maxAngularCorrection = (8.0 / 180.0 * Math.PI);\n\n/**\n * The maximum linear velocity of a body. This limit is very large and is used\n * to prevent numerical problems. You shouldn't need to adjust this.\n */\nSettings.maxTranslation = 2.0;\nSettings.maxTranslationSquared = (Settings.maxTranslation * Settings.maxTranslation);\n\n/**\n * The maximum angular velocity of a body. This limit is very large and is used\n * to prevent numerical problems. You shouldn't need to adjust this.\n */\nSettings.maxRotation = (0.5 * Math.PI)\nSettings.maxRotationSquared = (Settings.maxRotation * Settings.maxRotation)\n\n/**\n * This scale factor controls how fast overlap is resolved. Ideally this would\n * be 1 so that overlap is removed in one time step. However using values close\n * to 1 often lead to overshoot.\n */\nSettings.baumgarte = 0.2;\nSettings.toiBaugarte = 0.75;\n\n// Sleep\n\n/**\n * The time that a body must be still before it will go to sleep.\n */\nSettings.timeToSleep = 0.5;\n\n/**\n * A body cannot sleep if its linear velocity is above this tolerance.\n */\nSettings.linearSleepTolerance = 0.01;\n\nSettings.linearSleepToleranceSqr = Math.pow(Settings.linearSleepTolerance, 2);\n\n/**\n * A body cannot sleep if its angular velocity is above this tolerance.\n */\nSettings.angularSleepTolerance = (2.0 / 180.0 * Math.PI);\n\nSettings.angularSleepToleranceSqr = Math.pow(Settings.angularSleepTolerance, 2);\n\n","/*\n * Planck.js\n * The MIT License\n * Copyright (c) 2021 Erin Catto, Ali Shakiba\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 all\n * 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 THE\n * SOFTWARE.\n */\n\nvar _DEBUG = typeof DEBUG === 'undefined' ? false : DEBUG;\nvar _ASSERT = typeof ASSERT === 'undefined' ? false : ASSERT;\n\nmodule.exports = Shape;\n\nvar Math = require('./common/Math');\n\n/**\n * A shape is used for collision detection. You can create a shape however you\n * like. Shapes used for simulation in World are created automatically when a\n * Fixture is created. Shapes may encapsulate one or more child shapes.\n */\nfunction Shape() {\n  this.m_type;\n  this.m_radius;\n}\n\nShape.prototype._reset = function() {\n};\n\nShape.prototype._serialize = function() {\n  return {};\n};\n\nShape.TYPES = {};\n\nShape._deserialize = function(data, context, restore) {\n  var clazz = Shape.TYPES[data.type];\n  return clazz && restore(clazz, data);\n};\n\nShape.isValid = function(shape) {\n  return !!shape;\n};\n\nShape.prototype.getRadius = function() {\n  return this.m_radius;\n};\n\n/**\n * Get the type of this shape. You can use this to down cast to the concrete\n * shape.\n * \n * @return the shape type.\n */\nShape.prototype.getType = function() {\n  return this.m_type;\n};\n\n/**\n * @deprecated Shapes should be treated as immutable.\n *\n * clone the concrete shape.\n */\nShape.prototype._clone = function() {\n};\n\n/**\n * // Get the number of child primitives.\n */\nShape.prototype.getChildCount = function() {\n};\n\n/**\n * Test a point for containment in this shape. This only works for convex\n * shapes.\n * \n * @param {Transform} xf The shape world transform.\n * @param p A point in world coordinates.\n */\nShape.prototype.testPoint = function(xf, p) {\n};\n\n/**\n * Cast a ray against a child shape.\n * \n * @param {RayCastOutput} output The ray-cast results.\n * @param {RayCastInput} input The ray-cast input parameters.\n * @param {Transform} transform The transform to be applied to the shape.\n * @param childIndex The child shape index\n */\nShape.prototype.rayCast = function(output, input, transform, childIndex) {\n};\n\n/**\n * Given a transform, compute the associated axis aligned bounding box for a\n * child shape.\n * \n * @param {AABB} aabb Returns the axis aligned box.\n * @param {Transform} xf The world transform of the shape.\n * @param childIndex The child shape\n */\nShape.prototype.computeAABB = function(aabb, xf, childIndex) {\n};\n\n/**\n * Compute the mass properties of this shape using its dimensions and density.\n * The inertia tensor is computed about the local origin.\n * \n * @param {MassData} massData Returns the mass data for this shape.\n * @param density The density in kilograms per meter squared.\n */\nShape.prototype.computeMass = function(massData, density) {\n};\n\n/**\n * @param {DistanceProxy} proxy\n */\nShape.prototype.computeDistanceProxy = function(proxy) {\n};\n","/*\n * Planck.js\n * The MIT License\n * Copyright (c) 2021 Erin Catto, Ali Shakiba\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 all\n * 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 THE\n * SOFTWARE.\n */\n\nvar _DEBUG = typeof DEBUG === 'undefined' ? false : DEBUG;\nvar _ASSERT = typeof ASSERT === 'undefined' ? false : ASSERT;\n\nmodule.exports = Solver;\nmodule.exports.TimeStep = TimeStep;\n\nvar Settings = require('./Settings');\nvar common = require('./util/common');\n\nvar Vec2 = require('./common/Vec2');\nvar Math = require('./common/Math');\n\nvar Body = require('./Body');\nvar Contact = require('./Contact');\nvar Joint = require('./Joint');\n\nvar TimeOfImpact = require('./collision/TimeOfImpact');\nvar TOIInput = TimeOfImpact.Input;\nvar TOIOutput = TimeOfImpact.Output;\n\nvar Distance = require('./collision/Distance');\nvar DistanceInput = Distance.Input;\nvar DistanceOutput = Distance.Output;\nvar DistanceProxy = Distance.Proxy;\nvar SimplexCache = Distance.Cache;\n\nfunction TimeStep(dt) {\n  this.dt = 0; // time step\n  this.inv_dt = 0; // inverse time step (0 if dt == 0)\n  this.velocityIterations = 0;\n  this.positionIterations = 0;\n  this.warmStarting = false;\n  this.blockSolve = true;\n\n  // timestep ratio for variable timestep\n  this.inv_dt0 = 0.0;\n  this.dtRatio = 1; // dt * inv_dt0\n}\n\nTimeStep.prototype.reset = function(dt) {\n  if (this.dt > 0.0) {\n    this.inv_dt0 = this.inv_dt;\n  }\n  this.dt = dt;\n  this.inv_dt = dt == 0 ? 0 : 1 / dt;\n  this.dtRatio = dt * this.inv_dt0;\n}\n\n/**\n * Finds and solves islands. An island is a connected subset of the world.\n * \n * @param {World} world\n */\nfunction Solver(world) {\n  this.m_world = world;\n  this.m_stack = [];\n  this.m_bodies = [];\n  this.m_contacts = [];\n  this.m_joints = [];\n}\n\nSolver.prototype.clear = function() {\n  this.m_stack.length = 0;\n  this.m_bodies.length = 0;\n  this.m_contacts.length = 0;\n  this.m_joints.length = 0;\n}\n\nSolver.prototype.addBody = function(body) {\n  _ASSERT && common.assert(body instanceof Body, 'Not a Body!', body);\n  this.m_bodies.push(body);\n  // why?\n//  body.c_position.c.setZero();\n//  body.c_position.a = 0;\n//  body.c_velocity.v.setZero();\n//  body.c_velocity.w = 0;\n};\n\nSolver.prototype.addContact = function(contact) {\n  _ASSERT && common.assert(contact instanceof Contact, 'Not a Contact!', contact);\n  this.m_contacts.push(contact);\n};\n\nSolver.prototype.addJoint = function(joint) {\n  _ASSERT && common.assert(joint instanceof Joint, 'Not a Joint!', joint);\n  this.m_joints.push(joint);\n};\n\n/**\n * @param {TimeStep} step\n */\nSolver.prototype.solveWorld = function(step) {\n  var world = this.m_world;\n\n  // Clear all the island flags.\n  for (var b = world.m_bodyList; b; b = b.m_next) {\n    b.m_islandFlag = false;\n  }\n  for (var c = world.m_contactList; c; c = c.m_next) {\n    c.m_islandFlag = false;\n  }\n  for (var j = world.m_jointList; j; j = j.m_next) {\n    j.m_islandFlag = false;\n  }\n\n  // Build and simulate all awake islands.\n  var stack = this.m_stack;\n  var loop = -1;\n  for (var seed = world.m_bodyList; seed; seed = seed.m_next) {\n    loop++;\n    if (seed.m_islandFlag) {\n      continue;\n    }\n\n    if (seed.isAwake() == false || seed.isActive() == false) {\n      continue;\n    }\n\n    // The seed can be dynamic or kinematic.\n    if (seed.isStatic()) {\n      continue;\n    }\n\n    // Reset island and stack.\n    this.clear();\n\n    stack.push(seed);\n\n    seed.m_islandFlag = true;\n\n    // Perform a depth first search (DFS) on the constraint graph.\n    while (stack.length > 0) {\n      // Grab the next body off the stack and add it to the island.\n      var b = stack.pop();\n      _ASSERT && common.assert(b.isActive() == true);\n      this.addBody(b);\n\n      // Make sure the body is awake.\n      b.setAwake(true);\n\n      // To keep islands as small as possible, we don't\n      // propagate islands across static bodies.\n      if (b.isStatic()) {\n        continue;\n      }\n      \n      // Search all contacts connected to this body.\n      for (var ce = b.m_contactList; ce; ce = ce.next) {\n        var contact = ce.contact;\n\n        // Has this contact already been added to an island?\n        if (contact.m_islandFlag) {\n          continue;\n        }\n\n        // Is this contact solid and touching?\n        if (contact.isEnabled() == false || contact.isTouching() == false) {\n          continue;\n        }\n\n        // Skip sensors.\n        var sensorA = contact.m_fixtureA.m_isSensor;\n        var sensorB = contact.m_fixtureB.m_isSensor;\n        if (sensorA || sensorB) {\n          continue;\n        }\n\n        this.addContact(contact);\n        contact.m_islandFlag = true;\n\n        var other = ce.other;\n\n        // Was the other body already added to this island?\n        if (other.m_islandFlag) {\n          continue;\n        }\n\n        // _ASSERT && common.assert(stack.length < world.m_bodyCount);\n        stack.push(other);\n        other.m_islandFlag = true;\n      }\n\n      // Search all joints connect to this body.\n      for (var je = b.m_jointList; je; je = je.next) {\n        if (je.joint.m_islandFlag == true) {\n          continue;\n        }\n\n        var other = je.other;\n\n        // Don't simulate joints connected to inactive bodies.\n        if (other.isActive() == false) {\n          continue;\n        }\n\n        this.addJoint(je.joint);\n        je.joint.m_islandFlag = true;\n\n        if (other.m_islandFlag) {\n          continue;\n        }\n\n        // _ASSERT && common.assert(stack.length < world.m_bodyCount);\n        stack.push(other);\n        other.m_islandFlag = true;\n      }\n    }\n\n    this.solveIsland(step);\n\n    // Post solve cleanup.\n    for (var i = 0; i < this.m_bodies.length; ++i) {\n      // Allow static bodies to participate in other islands.\n      // TODO: are they added at all?\n      var b = this.m_bodies[i];\n      if (b.isStatic()) {\n        b.m_islandFlag = false;\n      }\n    }\n  }\n}\n\n/**\n * @param {TimeStep} step\n */\nSolver.prototype.solveIsland = function(step) {\n  // B2: Island Solve\n  var world = this.m_world;\n  var gravity = world.m_gravity;\n  var allowSleep = world.m_allowSleep;\n\n  var h = step.dt;\n\n  // Integrate velocities and apply damping. Initialize the body state.\n  for (var i = 0; i < this.m_bodies.length; ++i) {\n    var body = this.m_bodies[i];\n\n    var c = Vec2.clone(body.m_sweep.c);\n    var a = body.m_sweep.a;\n    var v = Vec2.clone(body.m_linearVelocity);\n    var w = body.m_angularVelocity;\n\n    // Store positions for continuous collision.\n    body.m_sweep.c0.set(body.m_sweep.c);\n    body.m_sweep.a0 = body.m_sweep.a;\n\n    if (body.isDynamic()) {\n      // Integrate velocities.\n      v.addMul(h * body.m_gravityScale, gravity);\n      v.addMul(h * body.m_invMass, body.m_force);\n      w += h * body.m_invI * body.m_torque;\n      /**\n       * <pre>\n       * Apply damping.\n       * ODE: dv/dt + c * v = 0\n       * Solution: v(t) = v0 * exp(-c * t)\n       * Time step: v(t + dt) = v0 * exp(-c * (t + dt)) = v0 * exp(-c * t) * exp(-c * dt) = v * exp(-c * dt)\n       * v2 = exp(-c * dt) * v1\n       * Pade approximation:\n       * v2 = v1 * 1 / (1 + c * dt)\n       * </pre>\n       */\n      v.mul(1.0 / (1.0 + h * body.m_linearDamping));\n      w *= 1.0 / (1.0 + h * body.m_angularDamping);\n    }\n\n    body.c_position.c = c;\n    body.c_position.a = a;\n    body.c_velocity.v = v;\n    body.c_velocity.w = w;\n  }\n\n  for (var i = 0; i < this.m_contacts.length; ++i) {\n    var contact = this.m_contacts[i];\n    contact.initConstraint(step);\n  }\n\n  _DEBUG && this.printBodies('M: ');\n\n  for (var i = 0; i < this.m_contacts.length; ++i) {\n    var contact = this.m_contacts[i];\n    contact.initVelocityConstraint(step);\n  }\n\n  _DEBUG && this.printBodies('R: ');\n\n  if (step.warmStarting) {\n    // Warm start.\n    for (var i = 0; i < this.m_contacts.length; ++i) {\n      var contact = this.m_contacts[i];\n      contact.warmStartConstraint(step);\n    }\n  }\n\n  _DEBUG && this.printBodies('Q: ');\n  \n  for (var i = 0; i < this.m_joints.length; ++i) {\n    var joint = this.m_joints[i];\n    joint.initVelocityConstraints(step);\n  }\n\n  _DEBUG && this.printBodies('E: ');\n\n  // Solve velocity constraints\n  for (var i = 0; i < step.velocityIterations; ++i) {\n    for (var j = 0; j < this.m_joints.length; ++j) {\n      var joint = this.m_joints[j];\n      joint.solveVelocityConstraints(step);\n    }\n\n    for (var j = 0; j < this.m_contacts.length; ++j) {\n      var contact = this.m_contacts[j];\n      contact.solveVelocityConstraint(step);\n    }\n  }\n\n  _DEBUG && this.printBodies('D: ');\n\n  // Store impulses for warm starting\n  for (var i = 0; i < this.m_contacts.length; ++i) {\n    var contact = this.m_contacts[i];\n    contact.storeConstraintImpulses(step);\n  }\n\n  _DEBUG && this.printBodies('C: ');\n\n  // Integrate positions\n  for (var i = 0; i < this.m_bodies.length; ++i) {\n    var body = this.m_bodies[i];\n\n    var c = Vec2.clone(body.c_position.c);\n    var a = body.c_position.a;\n    var v = Vec2.clone(body.c_velocity.v);\n    var w = body.c_velocity.w;\n\n    // Check for large velocities\n    var translation = Vec2.mul(h, v);\n    if (Vec2.lengthSquared(translation) > Settings.maxTranslationSquared) {\n      var ratio = Settings.maxTranslation / translation.length();\n      v.mul(ratio);\n    }\n\n    var rotation = h * w;\n    if (rotation * rotation > Settings.maxRotationSquared) {\n      var ratio = Settings.maxRotation / Math.abs(rotation);\n      w *= ratio;\n    }\n\n    // Integrate\n    c.addMul(h, v);\n    a += h * w;\n\n    body.c_position.c.set(c);\n    body.c_position.a = a;\n    body.c_velocity.v.set(v);\n    body.c_velocity.w = w;\n  }\n\n  _DEBUG && this.printBodies('B: ');\n\n  // Solve position constraints\n  var positionSolved = false;\n  for (var i = 0; i < step.positionIterations; ++i) {\n    var minSeparation = 0.0;\n    for (var j = 0; j < this.m_contacts.length; ++j) {\n      var contact = this.m_contacts[j];\n      var separation = contact.solvePositionConstraint(step);\n      minSeparation = Math.min(minSeparation, separation);\n    }\n    // We can't expect minSpeparation >= -Settings.linearSlop because we don't\n    // push the separation above -Settings.linearSlop.\n    var contactsOkay = minSeparation >= -3.0 * Settings.linearSlop;\n\n    var jointsOkay = true;\n    for (var j = 0; j < this.m_joints.length; ++j) {\n      var joint = this.m_joints[j];\n      var jointOkay = joint.solvePositionConstraints(step);\n      jointsOkay = jointsOkay && jointOkay;\n    }\n\n    if (contactsOkay && jointsOkay) {\n      // Exit early if the position errors are small.\n      positionSolved = true;\n      break;\n    }\n  }\n\n  _DEBUG && this.printBodies('L: ');\n\n  // Copy state buffers back to the bodies\n  for (var i = 0; i < this.m_bodies.length; ++i) {\n    var body = this.m_bodies[i];\n\n    body.m_sweep.c.set(body.c_position.c);\n    body.m_sweep.a = body.c_position.a;\n    body.m_linearVelocity.set(body.c_velocity.v);\n    body.m_angularVelocity = body.c_velocity.w;\n    body.synchronizeTransform();\n  }\n\n  this.postSolveIsland();\n\n  if (allowSleep) {\n    var minSleepTime = Infinity;\n\n    var linTolSqr = Settings.linearSleepToleranceSqr;\n    var angTolSqr = Settings.angularSleepToleranceSqr;\n\n    for (var i = 0; i < this.m_bodies.length; ++i) {\n      var body = this.m_bodies[i];\n      if (body.isStatic()) {\n        continue;\n      }\n\n      if ((body.m_autoSleepFlag == false)\n          || (body.m_angularVelocity * body.m_angularVelocity > angTolSqr)\n          || (Vec2.lengthSquared(body.m_linearVelocity) > linTolSqr)) {\n        body.m_sleepTime = 0.0;\n        minSleepTime = 0.0;\n      } else {\n        body.m_sleepTime += h;\n        minSleepTime = Math.min(minSleepTime, body.m_sleepTime);\n      }\n    }\n\n    if (minSleepTime >= Settings.timeToSleep && positionSolved) {\n      for (var i = 0; i < this.m_bodies.length; ++i) {\n        var body = this.m_bodies[i];\n        body.setAwake(false);\n      }\n    }\n  }\n};\n\nSolver.prototype.printBodies = function(tag) {\n  for (var i = 0; i < this.m_bodies.length; ++i) {\n    var b = this.m_bodies[i];\n    common.debug(tag, b.c_position.a, b.c_position.c.x, b.c_position.c.y, b.c_velocity.w, b.c_velocity.v.x, b.c_velocity.v.y);\n  }\n};\n\nvar s_subStep = new TimeStep(); // reuse\n\n/**\n * Find TOI contacts and solve them.\n *\n * @param {TimeStep} step\n */\nSolver.prototype.solveWorldTOI = function(step) {\n  var world = this.m_world;\n\n  if (world.m_stepComplete) {\n    for (var b = world.m_bodyList; b; b = b.m_next) {\n      b.m_islandFlag = false;\n      b.m_sweep.alpha0 = 0.0;\n    }\n\n    for (var c = world.m_contactList; c; c = c.m_next) {\n      // Invalidate TOI\n      c.m_toiFlag = false;\n      c.m_islandFlag = false;\n      c.m_toiCount = 0;\n      c.m_toi = 1.0;\n    }\n  }\n\n  // Find TOI events and solve them.\n  for (;;) {\n    // Find the first TOI.\n    var minContact = null; // Contact\n    var minAlpha = 1.0;\n\n    for (var c = world.m_contactList; c; c = c.m_next) {\n      // Is this contact disabled?\n      if (c.isEnabled() == false) {\n        continue;\n      }\n\n      // Prevent excessive sub-stepping.\n      if (c.m_toiCount > Settings.maxSubSteps) {\n        continue;\n      }\n\n      var alpha = 1.0;\n      if (c.m_toiFlag) {\n        // This contact has a valid cached TOI.\n        alpha = c.m_toi;\n      } else {\n        var fA = c.getFixtureA();\n        var fB = c.getFixtureB();\n\n        // Is there a sensor?\n        if (fA.isSensor() || fB.isSensor()) {\n          continue;\n        }\n\n        var bA = fA.getBody();\n        var bB = fB.getBody();\n\n        _ASSERT && common.assert(bA.isDynamic() || bB.isDynamic());\n\n        var activeA = bA.isAwake() && !bA.isStatic();\n        var activeB = bB.isAwake() && !bB.isStatic();\n\n        // Is at least one body active (awake and dynamic or kinematic)?\n        if (activeA == false && activeB == false) {\n          continue;\n        }\n\n        var collideA = bA.isBullet() || !bA.isDynamic();\n        var collideB = bB.isBullet() || !bB.isDynamic();\n\n        // Are these two non-bullet dynamic bodies?\n        if (collideA == false && collideB == false) {\n          continue;\n        }\n\n        // Compute the TOI for this contact.\n        // Put the sweeps onto the same time interval.\n        var alpha0 = bA.m_sweep.alpha0;\n\n        if (bA.m_sweep.alpha0 < bB.m_sweep.alpha0) {\n          alpha0 = bB.m_sweep.alpha0;\n          bA.m_sweep.advance(alpha0);\n        } else if (bB.m_sweep.alpha0 < bA.m_sweep.alpha0) {\n          alpha0 = bA.m_sweep.alpha0;\n          bB.m_sweep.advance(alpha0);\n        }\n\n        _ASSERT && common.assert(alpha0 < 1.0);\n\n        var indexA = c.getChildIndexA();\n        var indexB = c.getChildIndexB();\n\n        var sweepA = bA.m_sweep;\n        var sweepB = bB.m_sweep;\n\n        // Compute the time of impact in interval [0, minTOI]\n        var input = new TOIInput(); // TODO: reuse\n        input.proxyA.set(fA.getShape(), indexA);\n        input.proxyB.set(fB.getShape(), indexB);\n        input.sweepA.set(bA.m_sweep);\n        input.sweepB.set(bB.m_sweep);\n        input.tMax = 1.0;\n\n        var output = new TOIOutput(); // TODO: reuse\n        TimeOfImpact(output, input);\n\n        // Beta is the fraction of the remaining portion of the [time?].\n        var beta = output.t;\n        if (output.state == TOIOutput.e_touching) {\n          alpha = Math.min(alpha0 + (1.0 - alpha0) * beta, 1.0);\n        } else {\n          alpha = 1.0;\n        }\n\n        c.m_toi = alpha;\n        c.m_toiFlag = true;\n      }\n\n      if (alpha < minAlpha) {\n        // This is the minimum TOI found so far.\n        minContact = c;\n        minAlpha = alpha;\n      }\n    }\n\n    if (minContact == null || 1.0 - 10.0 * Math.EPSILON < minAlpha) {\n      // No more TOI events. Done!\n      world.m_stepComplete = true;\n      break;\n    }\n\n    // Advance the bodies to the TOI.\n    var fA = minContact.getFixtureA();\n    var fB = minContact.getFixtureB();\n    var bA = fA.getBody();\n    var bB = fB.getBody();\n\n    var backup1 = bA.m_sweep.clone();\n    var backup2 = bB.m_sweep.clone();\n\n    bA.advance(minAlpha);\n    bB.advance(minAlpha);\n\n    // The TOI contact likely has some new contact points.\n    minContact.update(world);\n    minContact.m_toiFlag = false;\n    ++minContact.m_toiCount;\n\n    // Is the contact solid?\n    if (minContact.isEnabled() == false || minContact.isTouching() == false) {\n      // Restore the sweeps.\n      minContact.setEnabled(false);\n      bA.m_sweep.set(backup1);\n      bB.m_sweep.set(backup2);\n      bA.synchronizeTransform();\n      bB.synchronizeTransform();\n      continue;\n    }\n\n    bA.setAwake(true);\n    bB.setAwake(true);\n\n    // Build the island\n    this.clear();\n    this.addBody(bA);\n    this.addBody(bB);\n    this.addContact(minContact);\n\n    bA.m_islandFlag = true;\n    bB.m_islandFlag = true;\n    minContact.m_islandFlag = true;\n\n    // Get contacts on bodyA and bodyB.\n    var bodies = [ bA, bB ];\n    for (var i = 0; i < bodies.length; ++i) {\n      var body = bodies[i];\n      if (body.isDynamic()) {\n        for (var ce = body.m_contactList; ce; ce = ce.next) {\n          // if (this.m_bodyCount == this.m_bodyCapacity) { break; }\n          // if (this.m_contactCount == this.m_contactCapacity) { break; }\n\n          var contact = ce.contact;\n\n          // Has this contact already been added to the island?\n          if (contact.m_islandFlag) {\n            continue;\n          }\n\n          // Only add if either is static, kinematic or bullet.\n          var other = ce.other;\n          if (other.isDynamic() && !body.isBullet() && !other.isBullet()) {\n            continue;\n          }\n\n          // Skip sensors.\n          var sensorA = contact.m_fixtureA.m_isSensor;\n          var sensorB = contact.m_fixtureB.m_isSensor;\n          if (sensorA || sensorB) {\n            continue;\n          }\n\n          // Tentatively advance the body to the TOI.\n          var backup = other.m_sweep.clone();\n          if (other.m_islandFlag == false) {\n            other.advance(minAlpha);\n          }\n\n          // Update the contact points\n          contact.update(world);\n\n          // Was the contact disabled by the user?\n          // Are there contact points?\n          if (contact.isEnabled() == false || contact.isTouching() == false) {\n            other.m_sweep.set(backup);\n            other.synchronizeTransform();\n            continue;\n          }\n\n          // Add the contact to the island\n          contact.m_islandFlag = true;\n          this.addContact(contact);\n\n          // Has the other body already been added to the island?\n          if (other.m_islandFlag) {\n            continue;\n          }\n\n          // Add the other body to the island.\n          other.m_islandFlag = true;\n\n          if (!other.isStatic()) {\n            other.setAwake(true);\n          }\n\n          this.addBody(other);\n        }\n      }\n    }\n\n    s_subStep.reset((1.0 - minAlpha) * step.dt);\n    s_subStep.dtRatio = 1.0;\n    s_subStep.positionIterations = 20;\n    s_subStep.velocityIterations = step.velocityIterations;\n    s_subStep.warmStarting = false;\n\n    this.solveIslandTOI(s_subStep, bA, bB);\n\n    // Reset island flags and synchronize broad-phase proxies.\n    for (var i = 0; i < this.m_bodies.length; ++i) {\n      var body = this.m_bodies[i];\n      body.m_islandFlag = false;\n\n      if (!body.isDynamic()) {\n        continue;\n      }\n\n      body.synchronizeFixtures();\n\n      // Invalidate all contact TOIs on this displaced body.\n      for (var ce = body.m_contactList; ce; ce = ce.next) {\n        ce.contact.m_toiFlag = false;\n        ce.contact.m_islandFlag = false;\n      }\n    }\n\n    // Commit fixture proxy movements to the broad-phase so that new contacts\n    // are created.\n    // Also, some contacts can be destroyed.\n    world.findNewContacts();\n\n    if (world.m_subStepping) {\n      world.m_stepComplete = false;\n      break;\n    }\n  }\n\n  if (_DEBUG) for (var b = world.m_bodyList; b; b = b.m_next) {\n    var c = b.m_sweep.c;\n    var a = b.m_sweep.a;\n    var v = b.m_linearVelocity;\n    var w = b.m_angularVelocity;\n  }\n}\n\n/**\n * @param {TimeStep} subStep\n * @param toiA\n * @param toiB\n */\nSolver.prototype.solveIslandTOI = function(subStep, toiA, toiB) {\n  var world = this.m_world;\n\n  // Initialize the body state.\n  for (var i = 0; i < this.m_bodies.length; ++i) {\n    var body = this.m_bodies[i];\n    body.c_position.c.set(body.m_sweep.c);\n    body.c_position.a = body.m_sweep.a;\n    body.c_velocity.v.set(body.m_linearVelocity);\n    body.c_velocity.w = body.m_angularVelocity;\n  }\n\n  for (var i = 0; i < this.m_contacts.length; ++i) {\n    var contact = this.m_contacts[i];\n    contact.initConstraint(subStep);\n  }\n\n  // Solve position constraints.\n  for (var i = 0; i < subStep.positionIterations; ++i) {\n    var minSeparation = 0.0;\n    for (var j = 0; j < this.m_contacts.length; ++j) {\n      var contact = this.m_contacts[j];\n      var separation = contact.solvePositionConstraintTOI(subStep, toiA, toiB);\n      minSeparation = Math.min(minSeparation, separation);\n    }\n    // We can't expect minSpeparation >= -Settings.linearSlop because we don't\n    // push the separation above -Settings.linearSlop.\n    var contactsOkay = minSeparation >= -1.5 * Settings.linearSlop;\n    if (contactsOkay) {\n      break;\n    }\n  }\n\n  if (false) {\n    // Is the new position really safe?\n    for (var i = 0; i < this.m_contacts.length; ++i) {\n      var c = this.m_contacts[i];\n      var fA = c.getFixtureA();\n      var fB = c.getFixtureB();\n\n      var bA = fA.getBody();\n      var bB = fB.getBody();\n\n      var indexA = c.getChildIndexA();\n      var indexB = c.getChildIndexB();\n\n      var input = new DistanceInput();\n      input.proxyA.set(fA.getShape(), indexA);\n      input.proxyB.set(fB.getShape(), indexB);\n      input.transformA = bA.getTransform();\n      input.transformB = bB.getTransform();\n      input.useRadii = false;\n\n      var output = new DistanceOutput();\n      var cache = new SimplexCache();\n      Distance(output, cache, input);\n\n      if (output.distance == 0 || cache.count == 3) {\n        cache.count += 0;\n      }\n    }\n  }\n\n  // Leap of faith to new safe state.\n  toiA.m_sweep.c0.set(toiA.c_position.c);\n  toiA.m_sweep.a0 = toiA.c_position.a;\n  toiB.m_sweep.c0.set(toiB.c_position.c);\n  toiB.m_sweep.a0 = toiB.c_position.a;\n\n  // No warm starting is needed for TOI events because warm\n  // starting impulses were applied in the discrete solver.\n  for (var i = 0; i < this.m_contacts.length; ++i) {\n    var contact = this.m_contacts[i];\n    contact.initVelocityConstraint(subStep);\n  }\n\n  // Solve velocity constraints.\n  for (var i = 0; i < subStep.velocityIterations; ++i) {\n    for (var j = 0; j < this.m_contacts.length; ++j) {\n      var contact = this.m_contacts[j];\n      contact.solveVelocityConstraint(subStep);\n    }\n  }\n\n  // Don't store the TOI contact forces for warm starting\n  // because they can be quite large.\n\n  var h = subStep.dt;\n\n  // Integrate positions\n  for (var i = 0; i < this.m_bodies.length; ++i) {\n    var body = this.m_bodies[i];\n\n    var c = Vec2.clone(body.c_position.c);\n    var a = body.c_position.a;\n    var v = Vec2.clone(body.c_velocity.v);\n    var w = body.c_velocity.w;\n\n    // Check for large velocities\n    var translation = Vec2.mul(h, v);\n    if (Vec2.dot(translation, translation) > Settings.maxTranslationSquared) {\n      var ratio = Settings.maxTranslation / translation.length();\n      v.mul(ratio);\n    }\n\n    var rotation = h * w;\n    if (rotation * rotation > Settings.maxRotationSquared) {\n      var ratio = Settings.maxRotation / Math.abs(rotation);\n      w *= ratio;\n    }\n\n    // Integrate\n    c.addMul(h, v);\n    a += h * w;\n\n    body.c_position.c = c;\n    body.c_position.a = a;\n    body.c_velocity.v = v;\n    body.c_velocity.w = w;\n\n    // Sync bodies\n    body.m_sweep.c = c;\n    body.m_sweep.a = a;\n    body.m_linearVelocity = v;\n    body.m_angularVelocity = w;\n    body.synchronizeTransform();\n  }\n\n  this.postSolveIsland();\n};\n\n/**\n * Contact impulses for reporting. Impulses are used instead of forces because\n * sub-step forces may approach infinity for rigid body collisions. These match\n * up one-to-one with the contact points in Manifold.\n */\nfunction ContactImpulse() {\n  this.normalImpulses = [];\n  this.tangentImpulses = [];\n};\n\nSolver.prototype.postSolveIsland = function() {\n  // TODO: report contact.v_points instead of new object?\n  var impulse = new ContactImpulse();\n  for (var c = 0; c < this.m_contacts.length; ++c) {\n    var contact = this.m_contacts[c];\n    for (var p = 0; p < contact.v_points.length; ++p) {\n      impulse.normalImpulses.push(contact.v_points[p].normalImpulse);\n      impulse.tangentImpulses.push(contact.v_points[p].tangentImpulse);\n    }\n    this.m_world.postSolve(contact, impulse);\n  }\n};\n","/*\n * Planck.js\n * The MIT License\n * Copyright (c) 2021 Erin Catto, Ali Shakiba\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 all\n * 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 THE\n * SOFTWARE.\n */\n\nvar _DEBUG = typeof DEBUG === 'undefined' ? false : DEBUG;\nvar _ASSERT = typeof ASSERT === 'undefined' ? false : ASSERT;\n\nmodule.exports = World;\n\nvar options = require('./util/options');\nvar common = require('./util/common');\nvar Vec2 = require('./common/Vec2');\nvar BroadPhase = require('./collision/BroadPhase');\nvar Solver = require('./Solver');\nvar Body = require('./Body');\nvar Joint = require('./Joint');\nvar Contact = require('./Contact');\n\n/**\n * @typedef {Object} WorldDef\n *\n * @prop {Vec2} [gravity = { x : 0, y : 0}]\n * @prop {boolean} [allowSleep = true]\n * @prop {boolean} [warmStarting = true]\n * @prop {boolean} [continuousPhysics = true]\n * @prop {boolean} [subStepping = false]\n * @prop {boolean} [blockSolve = true]\n * @prop {int} [velocityIterations = 8] For the velocity constraint solver.\n * @prop {int} [positionIterations = 3] For the position constraint solver.\n */\nvar WorldDef = {\n  gravity : Vec2.zero(),\n  allowSleep : true,\n  warmStarting : true,\n  continuousPhysics : true,\n  subStepping : false,\n  blockSolve : true,\n  velocityIterations : 8,\n  positionIterations : 3\n};\n\n/**\n * @param {WorldDef|Vec2} def World definition or gravity vector.\n */\nfunction World(def) {\n  if (!(this instanceof World)) {\n    return new World(def);\n  }\n\n  if (def && Vec2.isValid(def)) {\n    def = {gravity : def};\n  }\n\n  def = options(def, WorldDef);\n\n  this.m_solver = new Solver(this);\n\n  this.m_broadPhase = new BroadPhase();\n\n  this.m_contactList = null;\n  this.m_contactCount = 0;\n\n  this.m_bodyList = null;\n  this.m_bodyCount = 0;\n\n  this.m_jointList = null;\n  this.m_jointCount = 0;\n\n  this.m_stepComplete = true;\n\n  this.m_allowSleep = def.allowSleep;\n  this.m_gravity = Vec2.clone(def.gravity);\n\n  this.m_clearForces = true;\n  this.m_newFixture = false;\n  this.m_locked = false;\n\n  // These are for debugging the solver.\n  this.m_warmStarting = def.warmStarting;\n  this.m_continuousPhysics = def.continuousPhysics;\n  this.m_subStepping = def.subStepping;\n\n  this.m_blockSolve = def.blockSolve;\n  this.m_velocityIterations = def.velocityIterations;\n  this.m_positionIterations = def.positionIterations;\n\n  this.m_t = 0;\n\n  // Broad-phase callback.\n  this.addPair = this.createContact.bind(this);\n}\n\nWorld.prototype._serialize = function() {\n  var bodies = [];\n  var joints = [];\n\n  for (var b = this.getBodyList(); b; b = b.getNext()) {\n    bodies.push(b);\n  }\n\n  for (var j = this.getJointList(); j; j = j.getNext()) {\n    if (typeof j._serialize === 'function') {\n      joints.push(j);\n    }\n  }\n\n  return {\n    gravity: this.m_gravity,\n    bodies: bodies,\n    joints: joints,\n  };\n};\n\nWorld._deserialize = function(data, context, restore) {\n  if (!data) {\n    return new World();\n  }\n\n  var world = new World(data.gravity);\n\n  if (data.bodies) {\n    for(var i = data.bodies.length - 1; i >= 0; i -= 1) {\n      world._addBody(restore(Body, data.bodies[i], world));\n    }\n  }\n\n  if (data.joints) {\n    for(var i = data.joints.length - 1; i >= 0; i--) {\n      world.createJoint(restore(Joint, data.joints[i], world));\n    }\n  }\n\n  return world;\n};\n\n/**\n * Get the world body list. With the returned body, use Body.getNext to get the\n * next body in the world list. A null body indicates the end of the list.\n *\n * @return the head of the world body list.\n */\nWorld.prototype.getBodyList = function() {\n  return this.m_bodyList;\n}\n\n/**\n * Get the world joint list. With the returned joint, use Joint.getNext to get\n * the next joint in the world list. A null joint indicates the end of the list.\n *\n * @return the head of the world joint list.\n */\nWorld.prototype.getJointList = function() {\n  return this.m_jointList;\n}\n\n/**\n * Get the world contact list. With the returned contact, use Contact.getNext to\n * get the next contact in the world list. A null contact indicates the end of\n * the list.\n *\n * @return the head of the world contact list. Warning: contacts are created and\n *         destroyed in the middle of a time step. Use ContactListener to avoid\n *         missing contacts.\n */\nWorld.prototype.getContactList = function() {\n  return this.m_contactList;\n}\n\nWorld.prototype.getBodyCount = function() {\n  return this.m_bodyCount;\n}\n\nWorld.prototype.getJointCount = function() {\n  return this.m_jointCount;\n}\n\n/**\n * Get the number of contacts (each may have 0 or more contact points).\n */\nWorld.prototype.getContactCount = function() {\n  return this.m_contactCount;\n}\n\n/**\n * Change the global gravity vector.\n */\nWorld.prototype.setGravity = function(gravity) {\n  this.m_gravity = gravity;\n}\n\n/**\n * Get the global gravity vector.\n */\nWorld.prototype.getGravity = function() {\n  return this.m_gravity;\n}\n\n/**\n * Is the world locked (in the middle of a time step).\n */\nWorld.prototype.isLocked = function() {\n  return this.m_locked;\n}\n\n/**\n * Enable/disable sleep.\n */\nWorld.prototype.setAllowSleeping = function(flag) {\n  if (flag == this.m_allowSleep) {\n    return;\n  }\n\n  this.m_allowSleep = flag;\n  if (this.m_allowSleep == false) {\n    for (var b = this.m_bodyList; b; b = b.m_next) {\n      b.setAwake(true);\n    }\n  }\n}\n\nWorld.prototype.getAllowSleeping = function() {\n  return this.m_allowSleep;\n}\n\n/**\n * Enable/disable warm starting. For testing.\n */\nWorld.prototype.setWarmStarting = function(flag) {\n  this.m_warmStarting = flag;\n}\n\nWorld.prototype.getWarmStarting = function() {\n  return this.m_warmStarting;\n}\n\n/**\n * Enable/disable continuous physics. For testing.\n */\nWorld.prototype.setContinuousPhysics = function(flag) {\n  this.m_continuousPhysics = flag;\n}\n\nWorld.prototype.getContinuousPhysics = function() {\n  return this.m_continuousPhysics;\n}\n\n/**\n * Enable/disable single stepped continuous physics. For testing.\n */\nWorld.prototype.setSubStepping = function(flag) {\n  this.m_subStepping = flag;\n}\n\nWorld.prototype.getSubStepping = function() {\n  return this.m_subStepping;\n}\n\n/**\n * Set flag to control automatic clearing of forces after each time step.\n */\nWorld.prototype.setAutoClearForces = function(flag) {\n  this.m_clearForces = flag;\n}\n\n/**\n * Get the flag that controls automatic clearing of forces after each time step.\n */\nWorld.prototype.getAutoClearForces = function() {\n  return this.m_clearForces;\n}\n\n/**\n * Manually clear the force buffer on all bodies. By default, forces are cleared\n * automatically after each call to step. The default behavior is modified by\n * calling setAutoClearForces. The purpose of this function is to support\n * sub-stepping. Sub-stepping is often used to maintain a fixed sized time step\n * under a variable frame-rate. When you perform sub-stepping you will disable\n * auto clearing of forces and instead call clearForces after all sub-steps are\n * complete in one pass of your game loop.\n *\n * @see setAutoClearForces\n */\nWorld.prototype.clearForces = function() {\n  for (var body = this.m_bodyList; body; body = body.getNext()) {\n    body.m_force.setZero();\n    body.m_torque = 0.0;\n  }\n}\n\n/**\n * @function World~rayCastCallback\n *\n * @param fixture\n */\n\n/**\n * Query the world for all fixtures that potentially overlap the provided AABB.\n *\n * @param {World~queryCallback} queryCallback Called for each fixture\n *          found in the query AABB. It may return `false` to terminate the\n *          query.\n *\n * @param aabb The query box.\n */\nWorld.prototype.queryAABB = function(aabb, queryCallback) {\n  _ASSERT && common.assert(typeof queryCallback === 'function');\n  var broadPhase = this.m_broadPhase;\n  this.m_broadPhase.query(aabb, function(proxyId) { //TODO GC\n    var proxy = broadPhase.getUserData(proxyId); // FixtureProxy\n    return queryCallback(proxy.fixture);\n  });\n}\n\n/**\n * @function World~rayCastCallback\n *\n * Callback class for ray casts. See World.rayCast\n *\n * Called for each fixture found in the query. You control how the ray cast\n * proceeds by returning a float: return -1: ignore this fixture and continue\n * return 0: terminate the ray cast return fraction: clip the ray to this point\n * return 1: don't clip the ray and continue\n *\n * @param fixture The fixture hit by the ray\n * @param point The point of initial intersection\n * @param normal The normal vector at the point of intersection\n * @param fraction\n *\n * @return {float} -1 to filter, 0 to terminate, fraction to clip the ray for\n *         closest hit, 1 to continue\n */\n\n/**\n *\n * Ray-cast the world for all fixtures in the path of the ray. Your callback\n * controls whether you get the closest point, any point, or n-points. The\n * ray-cast ignores shapes that contain the starting point.\n *\n * @param {World~RayCastCallback} reportFixtureCallback A user implemented\n *          callback function.\n * @param point1 The ray starting point\n * @param point2 The ray ending point\n */\nWorld.prototype.rayCast = function(point1, point2, reportFixtureCallback) {\n  _ASSERT && common.assert(typeof reportFixtureCallback === 'function');\n  var broadPhase = this.m_broadPhase;\n\n  this.m_broadPhase.rayCast({\n    maxFraction : 1.0,\n    p1 : point1,\n    p2 : point2\n  }, function(input, proxyId) { // TODO GC\n    var proxy = broadPhase.getUserData(proxyId); // FixtureProxy\n    var fixture = proxy.fixture;\n    var index = proxy.childIndex;\n    var output = {}; // TODO GC\n    var hit = fixture.rayCast(output, input, index);\n    if (hit) {\n      var fraction = output.fraction;\n      var point = Vec2.add(Vec2.mul((1.0 - fraction), input.p1), Vec2.mul(fraction, input.p2));\n      return reportFixtureCallback(fixture, point, output.normal, fraction);\n    }\n    return input.maxFraction;\n  });\n}\n\n/**\n * Get the number of broad-phase proxies.\n */\nWorld.prototype.getProxyCount = function() {\n  return this.m_broadPhase.getProxyCount();\n}\n\n/**\n * Get the height of broad-phase dynamic tree.\n */\nWorld.prototype.getTreeHeight = function() {\n  return this.m_broadPhase.getTreeHeight();\n}\n\n/**\n * Get the balance of broad-phase dynamic tree.\n *\n * @returns {int}\n */\nWorld.prototype.getTreeBalance = function() {\n  return this.m_broadPhase.getTreeBalance();\n}\n\n/**\n * Get the quality metric of broad-phase dynamic tree. The smaller the better.\n * The minimum is 1.\n *\n * @returns {float}\n */\nWorld.prototype.getTreeQuality = function() {\n  return this.m_broadPhase.getTreeQuality();\n}\n\n/**\n * Shift the world origin. Useful for large worlds. The body shift formula is:\n * position -= newOrigin\n *\n * @param {Vec2} newOrigin The new origin with respect to the old origin\n */\nWorld.prototype.shiftOrigin = function(newOrigin) {\n  _ASSERT && common.assert(this.m_locked == false);\n  if (this.m_locked) {\n    return;\n  }\n\n  for (var b = this.m_bodyList; b; b = b.m_next) {\n    b.m_xf.p.sub(newOrigin);\n    b.m_sweep.c0.sub(newOrigin);\n    b.m_sweep.c.sub(newOrigin);\n  }\n\n  for (var j = this.m_jointList; j; j = j.m_next) {\n    j.shiftOrigin(newOrigin);\n  }\n\n  this.m_broadPhase.shiftOrigin(newOrigin);\n}\n\n/**\n * @internal Used for deserialize.\n */\nWorld.prototype._addBody = function(body) {\n  _ASSERT && common.assert(this.isLocked() === false);\n  if (this.isLocked()) {\n    return;\n  }\n\n  // Add to world doubly linked list.\n  body.m_prev = null;\n  body.m_next = this.m_bodyList;\n  if (this.m_bodyList) {\n    this.m_bodyList.m_prev = body;\n  }\n  this.m_bodyList = body;\n  ++this.m_bodyCount;\n}\n\n/**\n * Create a rigid body given a definition. No reference to the definition is\n * retained.\n *\n * Warning: This function is locked during callbacks.\n *\n * @param {BodyDef|Vec2} def Body definition or position.\n * @param {float} angle Body angle if def is position.\n */\nWorld.prototype.createBody = function(def, angle) {\n  _ASSERT && common.assert(this.isLocked() == false);\n  if (this.isLocked()) {\n    return null;\n  }\n\n  if (def && Vec2.isValid(def)) {\n    def = {\n      position : def,\n      angle : angle\n    };\n  }\n\n  var body = new Body(this, def);\n\n  this._addBody(body);\n\n  return body;\n}\n\nWorld.prototype.createDynamicBody = function(def, angle) {\n  if (!def) {\n    def = {};\n  } else if (Vec2.isValid(def)) {\n    def = { position : def, angle : angle };\n  }\n  def.type = 'dynamic';\n  return this.createBody(def);\n}\n\nWorld.prototype.createKinematicBody = function(def, angle) {\n  if (!def) {\n    def = {};\n  } else if (Vec2.isValid(def)) {\n    def = { position : def, angle : angle };\n  }\n  def.type = 'kinematic';\n  return this.createBody(def);\n}\n\n/**\n * Destroy a rigid body given a definition. No reference to the definition is\n * retained.\n *\n * Warning: This automatically deletes all associated shapes and joints.\n *\n * Warning: This function is locked during callbacks.\n *\n * @param {Body} b\n */\nWorld.prototype.destroyBody = function(b) {\n  _ASSERT && common.assert(this.m_bodyCount > 0);\n  _ASSERT && common.assert(this.isLocked() == false);\n  if (this.isLocked()) {\n    return;\n  }\n\n  if (b.m_destroyed) {\n    return false;\n  }\n\n  // Delete the attached joints.\n  var je = b.m_jointList;\n  while (je) {\n    var je0 = je;\n    je = je.next;\n\n    this.publish('remove-joint', je0.joint);\n    this.destroyJoint(je0.joint);\n\n    b.m_jointList = je;\n  }\n  b.m_jointList = null;\n\n  // Delete the attached contacts.\n  var ce = b.m_contactList;\n  while (ce) {\n    var ce0 = ce;\n    ce = ce.next;\n\n    this.destroyContact(ce0.contact);\n\n    b.m_contactList = ce;\n  }\n  b.m_contactList = null;\n\n  // Delete the attached fixtures. This destroys broad-phase proxies.\n  var f = b.m_fixtureList;\n  while (f) {\n    var f0 = f;\n    f = f.m_next;\n\n    this.publish('remove-fixture', f0);\n    f0.destroyProxies(this.m_broadPhase);\n\n    b.m_fixtureList = f;\n  }\n  b.m_fixtureList = null;\n\n  // Remove world body list.\n  if (b.m_prev) {\n    b.m_prev.m_next = b.m_next;\n  }\n\n  if (b.m_next) {\n    b.m_next.m_prev = b.m_prev;\n  }\n\n  if (b == this.m_bodyList) {\n    this.m_bodyList = b.m_next;\n  }\n\n  b.m_destroyed = true;\n\n  --this.m_bodyCount;\n\n  this.publish('remove-body', b);\n\n  return true;\n}\n\n/**\n * Create a joint to constrain bodies together. No reference to the definition\n * is retained. This may cause the connected bodies to cease colliding.\n *\n * Warning: This function is locked during callbacks.\n *\n * @param {Joint} join\n * @param {Body} bodyB\n * @param {Body} bodyA\n */\nWorld.prototype.createJoint = function(joint) {\n  _ASSERT && common.assert(!!joint.m_bodyA);\n  _ASSERT && common.assert(!!joint.m_bodyB);\n  _ASSERT && common.assert(this.isLocked() == false);\n  if (this.isLocked()) {\n    return null;\n  }\n\n  // Connect to the world list.\n  joint.m_prev = null;\n  joint.m_next = this.m_jointList;\n  if (this.m_jointList) {\n    this.m_jointList.m_prev = joint;\n  }\n  this.m_jointList = joint;\n  ++this.m_jointCount;\n\n  // Connect to the bodies' doubly linked lists.\n  joint.m_edgeA.joint = joint;\n  joint.m_edgeA.other = joint.m_bodyB;\n  joint.m_edgeA.prev = null;\n  joint.m_edgeA.next = joint.m_bodyA.m_jointList;\n  if (joint.m_bodyA.m_jointList)\n    joint.m_bodyA.m_jointList.prev = joint.m_edgeA;\n  joint.m_bodyA.m_jointList = joint.m_edgeA;\n\n  joint.m_edgeB.joint = joint;\n  joint.m_edgeB.other = joint.m_bodyA;\n  joint.m_edgeB.prev = null;\n  joint.m_edgeB.next = joint.m_bodyB.m_jointList;\n  if (joint.m_bodyB.m_jointList)\n    joint.m_bodyB.m_jointList.prev = joint.m_edgeB;\n  joint.m_bodyB.m_jointList = joint.m_edgeB;\n\n  // If the joint prevents collisions, then flag any contacts for filtering.\n  if (joint.m_collideConnected == false) {\n    for (var edge = joint.m_bodyB.getContactList(); edge; edge = edge.next) {\n      if (edge.other == joint.m_bodyA) {\n        // Flag the contact for filtering at the next time step (where either\n        // body is awake).\n        edge.contact.flagForFiltering();\n      }\n    }\n  }\n\n  // Note: creating a joint doesn't wake the bodies.\n\n  return joint;\n}\n\n/**\n * Destroy a joint. This may cause the connected bodies to begin colliding.\n * Warning: This function is locked during callbacks.\n *\n * @param {Joint} join\n */\nWorld.prototype.destroyJoint = function(joint) {\n  _ASSERT && common.assert(this.isLocked() == false);\n  if (this.isLocked()) {\n    return;\n  }\n\n  // Remove from the doubly linked list.\n  if (joint.m_prev) {\n    joint.m_prev.m_next = joint.m_next;\n  }\n\n  if (joint.m_next) {\n    joint.m_next.m_prev = joint.m_prev;\n  }\n\n  if (joint == this.m_jointList) {\n    this.m_jointList = joint.m_next;\n  }\n\n  // Disconnect from bodies.\n  var bodyA = joint.m_bodyA;\n  var bodyB = joint.m_bodyB;\n\n  // Wake up connected bodies.\n  bodyA.setAwake(true);\n  bodyB.setAwake(true);\n\n  // Remove from body 1.\n  if (joint.m_edgeA.prev) {\n    joint.m_edgeA.prev.next = joint.m_edgeA.next;\n  }\n\n  if (joint.m_edgeA.next) {\n    joint.m_edgeA.next.prev = joint.m_edgeA.prev;\n  }\n\n  if (joint.m_edgeA == bodyA.m_jointList) {\n    bodyA.m_jointList = joint.m_edgeA.next;\n  }\n\n  joint.m_edgeA.prev = null;\n  joint.m_edgeA.next = null;\n\n  // Remove from body 2\n  if (joint.m_edgeB.prev) {\n    joint.m_edgeB.prev.next = joint.m_edgeB.next;\n  }\n\n  if (joint.m_edgeB.next) {\n    joint.m_edgeB.next.prev = joint.m_edgeB.prev;\n  }\n\n  if (joint.m_edgeB == bodyB.m_jointList) {\n    bodyB.m_jointList = joint.m_edgeB.next;\n  }\n\n  joint.m_edgeB.prev = null;\n  joint.m_edgeB.next = null;\n\n  _ASSERT && common.assert(this.m_jointCount > 0);\n  --this.m_jointCount;\n\n  // If the joint prevents collisions, then flag any contacts for filtering.\n  if (joint.m_collideConnected == false) {\n    var edge = bodyB.getContactList();\n    while (edge) {\n      if (edge.other == bodyA) {\n        // Flag the contact for filtering at the next time step (where either\n        // body is awake).\n        edge.contact.flagForFiltering();\n      }\n\n      edge = edge.next;\n    }\n  }\n\n  this.publish('remove-joint', joint);\n}\n\nvar s_step = new Solver.TimeStep(); // reuse\n\n/**\n * Take a time step. This performs collision detection, integration, and\n * constraint solution.\n *\n * Broad-phase, narrow-phase, solve and solve time of impacts.\n *\n * @param {float} timeStep Time step, this should not vary.\n * @param {int} velocityIterations\n * @param {int} positionIterations\n */\nWorld.prototype.step = function(timeStep, velocityIterations, positionIterations) {\n  this.publish('pre-step', timeStep);\n\n  if ((velocityIterations | 0) !== velocityIterations) {\n    // TODO: remove this in future\n    velocityIterations = 0;\n  }\n\n  velocityIterations = velocityIterations || this.m_velocityIterations;\n  positionIterations = positionIterations || this.m_positionIterations;\n\n  // If new fixtures were added, we need to find the new contacts.\n  if (this.m_newFixture) {\n    this.findNewContacts();\n    this.m_newFixture = false;\n  }\n\n  this.m_locked = true;\n\n  s_step.reset(timeStep);\n  s_step.velocityIterations = velocityIterations;\n  s_step.positionIterations = positionIterations;\n  s_step.warmStarting = this.m_warmStarting;\n  s_step.blockSolve = this.m_blockSolve;\n\n  // Update contacts. This is where some contacts are destroyed.\n  this.updateContacts();\n\n  // Integrate velocities, solve velocity constraints, and integrate positions.\n  if (this.m_stepComplete && timeStep > 0.0) {\n    this.m_solver.solveWorld(s_step);\n\n    // Synchronize fixtures, check for out of range bodies.\n    for (var b = this.m_bodyList; b; b = b.getNext()) {\n      // If a body was not in an island then it did not move.\n      if (b.m_islandFlag == false) {\n        continue;\n      }\n\n      if (b.isStatic()) {\n        continue;\n      }\n\n      // Update fixtures (for broad-phase).\n      b.synchronizeFixtures();\n    }\n    // Look for new contacts.\n    this.findNewContacts();\n  }\n\n  // Handle TOI events.\n  if (this.m_continuousPhysics && timeStep > 0.0) {\n    this.m_solver.solveWorldTOI(s_step);\n  }\n\n  if (this.m_clearForces) {\n    this.clearForces();\n  }\n\n  this.m_locked = false;\n\n  this.publish('post-step', timeStep);\n}\n\n/**\n * Call this method to find new contacts.\n */\nWorld.prototype.findNewContacts = function() {\n  this.m_broadPhase.updatePairs(this.addPair);\n}\n\n/**\n * @private\n *\n * @param {FixtureProxy} proxyA\n * @param {FixtureProxy} proxyB\n */\nWorld.prototype.createContact = function(proxyA, proxyB) {\n  var fixtureA = proxyA.fixture;\n  var fixtureB = proxyB.fixture;\n\n  var indexA = proxyA.childIndex;\n  var indexB = proxyB.childIndex;\n\n  var bodyA = fixtureA.getBody();\n  var bodyB = fixtureB.getBody();\n\n  // Are the fixtures on the same body?\n  if (bodyA == bodyB) {\n    return;\n  }\n\n  // TODO_ERIN use a hash table to remove a potential bottleneck when both\n  // bodies have a lot of contacts.\n  // Does a contact already exist?\n  var edge = bodyB.getContactList(); // ContactEdge\n  while (edge) {\n    if (edge.other == bodyA) {\n      var fA = edge.contact.getFixtureA();\n      var fB = edge.contact.getFixtureB();\n      var iA = edge.contact.getChildIndexA();\n      var iB = edge.contact.getChildIndexB();\n\n      if (fA == fixtureA && fB == fixtureB && iA == indexA && iB == indexB) {\n        // A contact already exists.\n        return;\n      }\n\n      if (fA == fixtureB && fB == fixtureA && iA == indexB && iB == indexA) {\n        // A contact already exists.\n        return;\n      }\n    }\n\n    edge = edge.next;\n  }\n\n  if (bodyB.shouldCollide(bodyA) == false) {\n    return;\n  }\n  if (fixtureB.shouldCollide(fixtureA) == false) {\n    return;\n  }\n\n  // Call the factory.\n  var contact = Contact.create(fixtureA, indexA, fixtureB, indexB);\n  if (contact == null) {\n    return;\n  }\n\n  // Insert into the world.\n  contact.m_prev = null;\n  if (this.m_contactList != null) {\n    contact.m_next = this.m_contactList;\n    this.m_contactList.m_prev = contact;\n  }\n  this.m_contactList = contact;\n\n  ++this.m_contactCount;\n}\n\n/**\n * Removes old non-overlapping contacts, applies filters and updates contacts.\n */\nWorld.prototype.updateContacts = function() {\n  // Update awake contacts.\n  var c, next_c = this.m_contactList;\n  while (c = next_c) {\n    next_c = c.getNext()\n    var fixtureA = c.getFixtureA();\n    var fixtureB = c.getFixtureB();\n    var indexA = c.getChildIndexA();\n    var indexB = c.getChildIndexB();\n    var bodyA = fixtureA.getBody();\n    var bodyB = fixtureB.getBody();\n\n    // Is this contact flagged for filtering?\n    if (c.m_filterFlag) {\n      if (bodyB.shouldCollide(bodyA) == false) {\n        this.destroyContact(c);\n        continue;\n      }\n\n      if (fixtureB.shouldCollide(fixtureA) == false) {\n        this.destroyContact(c);\n        continue;\n      }\n\n      // Clear the filtering flag.\n      c.m_filterFlag = false;\n    }\n\n    var activeA = bodyA.isAwake() && !bodyA.isStatic();\n    var activeB = bodyB.isAwake() && !bodyB.isStatic();\n\n    // At least one body must be awake and it must be dynamic or kinematic.\n    if (activeA == false && activeB == false) {\n      continue;\n    }\n\n    var proxyIdA = fixtureA.m_proxies[indexA].proxyId;\n    var proxyIdB = fixtureB.m_proxies[indexB].proxyId;\n    var overlap = this.m_broadPhase.testOverlap(proxyIdA, proxyIdB);\n\n    // Here we destroy contacts that cease to overlap in the broad-phase.\n    if (overlap == false) {\n      this.destroyContact(c);\n      continue;\n    }\n\n    // The contact persists.\n    c.update(this);\n  }\n}\n\n/**\n * @param {Contact} contact\n */\nWorld.prototype.destroyContact = function(contact) {\n  Contact.destroy(contact, this);\n\n  // Remove from the world.\n  if (contact.m_prev) {\n    contact.m_prev.m_next = contact.m_next;\n  }\n  if (contact.m_next) {\n    contact.m_next.m_prev = contact.m_prev;\n  }\n  if (contact == this.m_contactList) {\n    this.m_contactList = contact.m_next;\n  }\n\n  --this.m_contactCount;\n}\n\nWorld.prototype._listeners = null;\n\n/**\n * Register an event listener.\n *\n * @param {string} name\n * @param {function} listener\n */\nWorld.prototype.on = function(name, listener) {\n  if (typeof name !== 'string' || typeof listener !== 'function') {\n    return this;\n  }\n  if (!this._listeners) {\n    this._listeners = {};\n  }\n  if (!this._listeners[name]) {\n    this._listeners[name] = [];\n  }\n  this._listeners[name].push(listener);\n  return this;\n};\n\n/**\n * Remove an event listener.\n *\n * @param {string} name\n * @param {function} listener\n */\nWorld.prototype.off = function(name, listener) {\n  if (typeof name !== 'string' || typeof listener !== 'function') {\n    return this;\n  }\n  var listeners = this._listeners && this._listeners[name];\n  if (!listeners || !listeners.length) {\n    return this;\n  }\n  var index = listeners.indexOf(listener);\n  if (index >= 0) {\n    listeners.splice(index, 1);\n  }\n  return this;\n};\n\nWorld.prototype.publish = function(name, arg1, arg2, arg3) {\n  var listeners = this._listeners && this._listeners[name];\n  if (!listeners || !listeners.length) {\n    return 0;\n  }\n  for (var l = 0; l < listeners.length; l++) {\n    listeners[l].call(this, arg1, arg2, arg3);\n  }\n  return listeners.length;\n};\n\n/**\n * @event World#remove-body\n * @event World#remove-joint\n * @event World#remove-fixture\n *\n * Joints and fixtures are destroyed when their associated body is destroyed.\n * Register a destruction listener so that you may nullify references to these\n * joints and shapes.\n *\n * `function(object)` is called when any joint or fixture is about to\n * be destroyed due to the destruction of one of its attached or parent bodies.\n */\n\n/**\n * @private\n * @param {Contact} contact\n */\nWorld.prototype.beginContact = function(contact) {\n  this.publish('begin-contact', contact);\n};\n\n/**\n * @event World#begin-contact\n *\n * Called when two fixtures begin to touch.\n *\n * Implement contact callbacks to get contact information. You can use these\n * results for things like sounds and game logic. You can also get contact\n * results by traversing the contact lists after the time step. However, you\n * might miss some contacts because continuous physics leads to sub-stepping.\n * Additionally you may receive multiple callbacks for the same contact in a\n * single time step. You should strive to make your callbacks efficient because\n * there may be many callbacks per time step.\n *\n * Warning: You cannot create/destroy world entities inside these callbacks.\n */\n\n/**\n * @private\n * @param {Contact} contact\n */\nWorld.prototype.endContact = function(contact) {\n  this.publish('end-contact', contact);\n};\n\n/**\n * @event World#end-contact\n *\n * Called when two fixtures cease to touch.\n *\n * Implement contact callbacks to get contact information. You can use these\n * results for things like sounds and game logic. You can also get contact\n * results by traversing the contact lists after the time step. However, you\n * might miss some contacts because continuous physics leads to sub-stepping.\n * Additionally you may receive multiple callbacks for the same contact in a\n * single time step. You should strive to make your callbacks efficient because\n * there may be many callbacks per time step.\n *\n * Warning: You cannot create/destroy world entities inside these callbacks.\n */\n\n/**\n * @private\n * @param {Contact} contact\n * @param {Manifold} oldManifold\n */\nWorld.prototype.preSolve = function(contact, oldManifold) {\n  this.publish('pre-solve', contact, oldManifold);\n};\n\n/**\n * @event World#pre-solve\n *\n * This is called after a contact is updated. This allows you to inspect a\n * contact before it goes to the solver. If you are careful, you can modify the\n * contact manifold (e.g. disable contact). A copy of the old manifold is\n * provided so that you can detect changes. Note: this is called only for awake\n * bodies. Note: this is called even when the number of contact points is zero.\n * Note: this is not called for sensors. Note: if you set the number of contact\n * points to zero, you will not get an endContact callback. However, you may get\n * a beginContact callback the next step.\n *\n * Warning: You cannot create/destroy world entities inside these callbacks.\n */\n\n/**\n * @private\n * @param {Contact} contact\n * @param {ContactImpulse} impulse\n */\nWorld.prototype.postSolve = function(contact, impulse) {\n  this.publish('post-solve', contact, impulse);\n};\n\n/**\n * @event World#post-solve\n *\n * This lets you inspect a contact after the solver is finished. This is useful\n * for inspecting impulses. Note: the contact manifold does not include time of\n * impact impulses, which can be arbitrarily large if the sub-step is small.\n * Hence the impulse is provided explicitly in a separate data structure. Note:\n * this is only called for contacts that are touching, solid, and awake.\n *\n * Warning: You cannot create/destroy world entities inside these callbacks.\n */\n\n/**\n * Register a contact filter to provide specific control over collision.\n * Otherwise the default filter is used (defaultFilter). The listener is owned\n * by you and must remain in scope.\n *\n * Moved to Fixture.\n */\n","/*\n * Planck.js\n * The MIT License\n * Copyright (c) 2021 Erin Catto, Ali Shakiba\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 all\n * 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 THE\n * SOFTWARE.\n */\n\nvar _DEBUG = typeof DEBUG === 'undefined' ? false : DEBUG;\nvar _ASSERT = typeof ASSERT === 'undefined' ? false : ASSERT;\n\nvar Settings = require('../Settings');\nvar common = require('../util/common');\nvar Math = require('../common/Math');\nvar Vec2 = require('../common/Vec2');\n\nmodule.exports = AABB;\n\nfunction AABB(lower, upper) {\n  if (!(this instanceof AABB)) {\n    return new AABB(lower, upper);\n  }\n\n  this.lowerBound = Vec2.zero();\n  this.upperBound = Vec2.zero();\n\n  if (typeof lower === 'object') {\n    this.lowerBound.set(lower);\n  }\n  if (typeof upper === 'object') {\n    this.upperBound.set(upper);\n  } else if (typeof lower === 'object') {\n    this.upperBound.set(lower);\n  }\n};\n\n/**\n * Verify that the bounds are sorted.\n */\nAABB.prototype.isValid = function() {\n  return AABB.isValid(this);\n}\n\nAABB.isValid = function(aabb) {\n  var d = Vec2.sub(aabb.upperBound, aabb.lowerBound);\n  var valid = d.x >= 0.0 && d.y >= 0.0 && Vec2.isValid(aabb.lowerBound) && Vec2.isValid(aabb.upperBound);\n  return valid;\n}\n\nAABB.assert = function(o) {\n  if (!_ASSERT) return;\n  if (!AABB.isValid(o)) {\n    _DEBUG && common.debug(o);\n    throw new Error('Invalid AABB!');\n  }\n}\n\n/**\n * Get the center of the AABB.\n */\nAABB.prototype.getCenter = function() {\n  return Vec2.neo((this.lowerBound.x + this.upperBound.x) * 0.5, (this.lowerBound.y + this.upperBound.y) * 0.5);\n}\n\n/**\n * Get the extents of the AABB (half-widths).\n */\nAABB.prototype.getExtents = function() {\n  return Vec2.neo((this.upperBound.x - this.lowerBound.x) * 0.5, (this.upperBound.y - this.lowerBound.y) * 0.5);\n}\n\n/**\n * Get the perimeter length.\n */\nAABB.prototype.getPerimeter = function() {\n  return 2.0 * (this.upperBound.x - this.lowerBound.x + this.upperBound.y - this.lowerBound.y);\n}\n\n/**\n * Combine one or two AABB into this one.\n */\nAABB.prototype.combine = function(a, b) {\n  b = b || this;\n\n  var lowerA = a.lowerBound;\n  var upperA = a.upperBound;\n  var lowerB = b.lowerBound;\n  var upperB = b.upperBound;\n\n  var lowerX = Math.min(lowerA.x, lowerB.x);\n  var lowerY = Math.min(lowerA.y, lowerB.y);\n  var upperX = Math.max(upperB.x, upperA.x);\n  var upperY = Math.max(upperB.y, upperA.y);\n\n  this.lowerBound.set(lowerX, lowerY);\n  this.upperBound.set(upperX, upperY);\n}\n\nAABB.prototype.combinePoints = function(a, b) {\n  this.lowerBound.set(Math.min(a.x, b.x), Math.min(a.y, b.y));\n  this.upperBound.set(Math.max(a.x, b.x), Math.max(a.y, b.y));\n}\n\nAABB.prototype.set = function(aabb) {\n  this.lowerBound.set(aabb.lowerBound.x, aabb.lowerBound.y);\n  this.upperBound.set(aabb.upperBound.x, aabb.upperBound.y);\n}\n\nAABB.prototype.contains = function(aabb) {\n  var result = true;\n  result = result && this.lowerBound.x <= aabb.lowerBound.x;\n  result = result && this.lowerBound.y <= aabb.lowerBound.y;\n  result = result && aabb.upperBound.x <= this.upperBound.x;\n  result = result && aabb.upperBound.y <= this.upperBound.y;\n  return result;\n}\n\nAABB.prototype.extend = function(value) {\n  AABB.extend(this, value);\n  return this;\n}\n\nAABB.extend = function(aabb, value) {\n  aabb.lowerBound.x -= value;\n  aabb.lowerBound.y -= value;\n  aabb.upperBound.x += value;\n  aabb.upperBound.y += value;\n}\n\nAABB.testOverlap = function(a, b) {\n  var d1x = b.lowerBound.x - a.upperBound.x;\n  var d2x = a.lowerBound.x - b.upperBound.x;\n\n  var d1y = b.lowerBound.y - a.upperBound.y;\n  var d2y = a.lowerBound.y - b.upperBound.y;\n\n  if (d1x > 0 || d1y > 0 || d2x > 0 || d2y > 0) {\n    return false;\n  }\n  return true;\n}\n\nAABB.areEqual = function(a, b) {\n  return Vec2.areEqual(a.lowerBound, b.lowerBound) && Vec2.areEqual(a.upperBound, b.upperBound);\n}\n\nAABB.diff = function(a, b) {\n  var wD = Math.max(0, Math.min(a.upperBound.x, b.upperBound.x) - Math.max(b.lowerBound.x, a.lowerBound.x))\n  var hD = Math.max(0, Math.min(a.upperBound.y, b.upperBound.y) - Math.max(b.lowerBound.y, a.lowerBound.y));\n\n  var wA = a.upperBound.x - a.lowerBound.x;\n  var hA = a.upperBound.y - a.lowerBound.y;\n\n  var wB = b.upperBound.x - b.lowerBound.x;\n  var hB = b.upperBound.y - b.lowerBound.y;\n\n  return wA * hA + wB * hB - wD * hD;\n};\n\n/**\n * @typedef RayCastInput\n *\n * Ray-cast input data. The ray extends from p1 to p1 + maxFraction * (p2 - p1).\n *\n * @prop {Vec2} p1\n * @prop {Vec2} p2\n * @prop {number} maxFraction\n */\n\n/**\n * @typedef RayCastInput\n *\n * Ray-cast output data. The ray hits at p1 + fraction * (p2 - p1), where p1 and\n * p2 come from RayCastInput.\n *\n * @prop {Vec2} normal\n * @prop {number} fraction\n */\n\n/**\n * @param {RayCastOutput} output\n * @param {RayCastInput} input\n * @returns {boolean}\n */\nAABB.prototype.rayCast = function(output, input) {\n  // From Real-time Collision Detection, p179.\n\n  var tmin = -Infinity;\n  var tmax = Infinity;\n\n  var p = input.p1;\n  var d = Vec2.sub(input.p2, input.p1);\n  var absD = Vec2.abs(d);\n\n  var normal = Vec2.zero();\n\n  for (var f = 'x'; f !== null; f = (f === 'x' ? 'y' : null)) {\n    if (absD.x < Math.EPSILON) {\n      // Parallel.\n      if (p[f] < this.lowerBound[f] || this.upperBound[f] < p[f]) {\n        return false;\n      }\n    } else {\n      var inv_d = 1.0 / d[f];\n      var t1 = (this.lowerBound[f] - p[f]) * inv_d;\n      var t2 = (this.upperBound[f] - p[f]) * inv_d;\n\n      // Sign of the normal vector.\n      var s = -1.0;\n\n      if (t1 > t2) {\n        var temp = t1;\n        t1 = t2, t2 = temp;\n        s = 1.0;\n      }\n\n      // Push the min up\n      if (t1 > tmin) {\n        normal.setZero();\n        normal[f] = s;\n        tmin = t1;\n      }\n\n      // Pull the max down\n      tmax = Math.min(tmax, t2);\n\n      if (tmin > tmax) {\n        return false;\n      }\n    }\n  }\n\n  // Does the ray start inside the box?\n  // Does the ray intersect beyond the max fraction?\n  if (tmin < 0.0 || input.maxFraction < tmin) {\n    return false;\n  }\n\n  // Intersection.\n  output.fraction = tmin;\n  output.normal = normal;\n  return true;\n}\n\nAABB.prototype.toString = function() {\n  return JSON.stringify(this);\n}\n","/*\n * Planck.js\n * The MIT License\n * Copyright (c) 2021 Erin Catto, Ali Shakiba\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 all\n * 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 THE\n * SOFTWARE.\n */\n\nvar _DEBUG = typeof DEBUG === 'undefined' ? false : DEBUG;\nvar _ASSERT = typeof ASSERT === 'undefined' ? false : ASSERT;\n\nvar Settings = require('../Settings');\nvar common = require('../util/common');\nvar Math = require('../common/Math');\nvar AABB = require('./AABB');\nvar DynamicTree = require('./DynamicTree');\n\nmodule.exports = BroadPhase;\n\n/**\n * The broad-phase wraps and extends a dynamic-tree to keep track of moved\n * objects and query them on update.\n */\nfunction BroadPhase() {\n  this.m_tree = new DynamicTree();\n  this.m_proxyCount = 0;\n  this.m_moveBuffer = [];\n  this.queryCallback = this.queryCallback.bind(this);\n};\n\n/**\n * Get user data from a proxy. Returns null if the id is invalid.\n */\nBroadPhase.prototype.getUserData = function(proxyId) {\n  return this.m_tree.getUserData(proxyId);\n}\n\n/**\n * Test overlap of fat AABBs.\n */\nBroadPhase.prototype.testOverlap = function(proxyIdA, proxyIdB) {\n  var aabbA = this.m_tree.getFatAABB(proxyIdA);\n  var aabbB = this.m_tree.getFatAABB(proxyIdB);\n  return AABB.testOverlap(aabbA, aabbB);\n}\n\n/**\n * Get the fat AABB for a proxy.\n */\nBroadPhase.prototype.getFatAABB = function(proxyId) {\n  return this.m_tree.getFatAABB(proxyId);\n}\n\n/**\n * Get the number of proxies.\n */\nBroadPhase.prototype.getProxyCount = function() {\n  return this.m_proxyCount;\n}\n\n/**\n * Get the height of the embedded tree.\n */\nBroadPhase.prototype.getTreeHeight = function() {\n  return this.m_tree.getHeight();\n}\n\n/**\n * Get the balance (integer) of the embedded tree.\n */\nBroadPhase.prototype.getTreeBalance = function() {\n  return this.m_tree.getMaxBalance();\n}\n\n/**\n * Get the quality metric of the embedded tree.\n */\nBroadPhase.prototype.getTreeQuality = function() {\n  return this.m_tree.getAreaRatio();\n}\n\n/**\n * Query an AABB for overlapping proxies. The callback class is called for each\n * proxy that overlaps the supplied AABB.\n */\nBroadPhase.prototype.query = function(aabb, queryCallback) {\n  this.m_tree.query(aabb, queryCallback);\n}\n\n/**\n * Ray-cast against the proxies in the tree. This relies on the callback to\n * perform a exact ray-cast in the case were the proxy contains a shape. The\n * callback also performs the any collision filtering. This has performance\n * roughly equal to k * log(n), where k is the number of collisions and n is the\n * number of proxies in the tree.\n * \n * @param input The ray-cast input data. The ray extends from p1 to p1 +\n *          maxFraction * (p2 - p1).\n * @param rayCastCallback A function that is called for each proxy that is hit by\n *          the ray.\n */\nBroadPhase.prototype.rayCast = function(input, rayCastCallback) {\n  this.m_tree.rayCast(input, rayCastCallback);\n}\n\n/**\n * Shift the world origin. Useful for large worlds. The shift formula is:\n * position -= newOrigin\n * \n * @param newOrigin The new origin with respect to the old origin\n */\nBroadPhase.prototype.shiftOrigin = function(newOrigin) {\n  this.m_tree.shiftOrigin(newOrigin);\n}\n\n/**\n * Create a proxy with an initial AABB. Pairs are not reported until UpdatePairs\n * is called.\n */\nBroadPhase.prototype.createProxy = function(aabb, userData) {\n  _ASSERT && common.assert(AABB.isValid(aabb));\n  var proxyId = this.m_tree.createProxy(aabb, userData);\n  this.m_proxyCount++;\n  this.bufferMove(proxyId);\n  return proxyId;\n}\n\n/**\n * Destroy a proxy. It is up to the client to remove any pairs.\n */\nBroadPhase.prototype.destroyProxy = function(proxyId) {\n  this.unbufferMove(proxyId);\n  this.m_proxyCount--;\n  this.m_tree.destroyProxy(proxyId);\n}\n\n/**\n * Call moveProxy as many times as you like, then when you are done call\n * UpdatePairs to finalized the proxy pairs (for your time step).\n */\nBroadPhase.prototype.moveProxy = function(proxyId, aabb, displacement) {\n  _ASSERT && common.assert(AABB.isValid(aabb));\n  var changed = this.m_tree.moveProxy(proxyId, aabb, displacement);\n  if (changed) {\n    this.bufferMove(proxyId);\n  }\n}\n\n/**\n * Call to trigger a re-processing of it's pairs on the next call to\n * UpdatePairs.\n */\nBroadPhase.prototype.touchProxy = function(proxyId) {\n  this.bufferMove(proxyId);\n}\n\nBroadPhase.prototype.bufferMove = function(proxyId) {\n  this.m_moveBuffer.push(proxyId);\n}\n\nBroadPhase.prototype.unbufferMove = function(proxyId) {\n  for (var i = 0; i < this.m_moveBuffer.length; ++i) {\n    if (this.m_moveBuffer[i] == proxyId) {\n      this.m_moveBuffer[i] = null;\n    }\n  }\n}\n\n/**\n * @function BroadPhase~addPair\n * @param {Object} userDataA\n * @param {Object} userDataB\n */\n\n/**\n * Update the pairs. This results in pair callbacks. This can only add pairs.\n * \n * @param {BroadPhase~AddPair} addPairCallback\n */\nBroadPhase.prototype.updatePairs = function(addPairCallback) {\n  _ASSERT && common.assert(typeof addPairCallback === 'function');\n  this.m_callback = addPairCallback;\n\n  // Perform tree queries for all moving proxies.\n  while (this.m_moveBuffer.length > 0) {\n    this.m_queryProxyId = this.m_moveBuffer.pop();\n    if (this.m_queryProxyId === null) {\n      continue;\n    }\n\n    // We have to query the tree with the fat AABB so that\n    // we don't fail to create a pair that may touch later.\n    var fatAABB = this.m_tree.getFatAABB(this.m_queryProxyId);\n\n    // Query tree, create pairs and add them pair buffer.\n    this.m_tree.query(fatAABB, this.queryCallback);\n  }\n\n  // Try to keep the tree balanced.\n  // this.m_tree.rebalance(4);\n}\n\nBroadPhase.prototype.queryCallback = function(proxyId) {\n  // A proxy cannot form a pair with itself.\n  if (proxyId == this.m_queryProxyId) {\n    return true;\n  }\n\n  var proxyIdA = Math.min(proxyId, this.m_queryProxyId);\n  var proxyIdB = Math.max(proxyId, this.m_queryProxyId);\n\n  // TODO: Skip any duplicate pairs.\n\n  var userDataA = this.m_tree.getUserData(proxyIdA);\n  var userDataB = this.m_tree.getUserData(proxyIdB);\n\n  // Send the pairs back to the client.\n  this.m_callback(userDataA, userDataB);\n\n  return true;\n}\n","/*\n * Planck.js\n * The MIT License\n * Copyright (c) 2021 Erin Catto, Ali Shakiba\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 all\n * 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 THE\n * SOFTWARE.\n */\n\nvar _DEBUG = typeof DEBUG === 'undefined' ? false : DEBUG;\nvar _ASSERT = typeof ASSERT === 'undefined' ? false : ASSERT;\n\nmodule.exports = Distance;\n\nmodule.exports.Input = DistanceInput;\nmodule.exports.Output = DistanceOutput;\nmodule.exports.Proxy = DistanceProxy;\nmodule.exports.Cache = SimplexCache;\n\nvar Settings = require('../Settings');\nvar common = require('../util/common');\n\nvar stats = require('../common/stats');\n\nvar Math = require('../common/Math');\nvar Vec2 = require('../common/Vec2');\nvar Vec3 = require('../common/Vec3');\nvar Mat22 = require('../common/Mat22');\nvar Mat33 = require('../common/Mat33');\nvar Rot = require('../common/Rot');\nvar Sweep = require('../common/Sweep');\nvar Transform = require('../common/Transform');\nvar Velocity = require('../common/Velocity');\nvar Position = require('../common/Position');\n\n/**\n * GJK using Voronoi regions (Christer Ericson) and Barycentric coordinates.\n */\n\nstats.gjkCalls = 0;\nstats.gjkIters = 0;\nstats.gjkMaxIters = 0;\n\n/**\n * Input for Distance. You have to option to use the shape radii in the\n * computation. Even\n */\nfunction DistanceInput() {\n  this.proxyA = new DistanceProxy();\n  this.proxyB = new DistanceProxy();\n  this.transformA = null;\n  this.transformB = null;\n  this.useRadii = false;\n};\n\n/**\n * Output for Distance.\n *\n * @prop {Vec2} pointA closest point on shapeA\n * @prop {Vec2} pointB closest point on shapeB\n * @prop distance\n * @prop iterations number of GJK iterations used\n */\nfunction DistanceOutput() {\n  this.pointA = Vec2.zero();\n  this.pointB = Vec2.zero();\n  this.distance;\n  this.iterations;\n}\n\n/**\n * Used to warm start Distance. Set count to zero on first call.\n *\n * @prop {number} metric length or area\n * @prop {array} indexA vertices on shape A\n * @prop {array} indexB vertices on shape B\n * @prop {number} count\n */\nfunction SimplexCache() {\n  this.metric = 0;\n  this.indexA = [];\n  this.indexB = [];\n  this.count = 0;\n};\n\n/**\n * Compute the closest points between two shapes. Supports any combination of:\n * CircleShape, PolygonShape, EdgeShape. The simplex cache is input/output. On\n * the first call set SimplexCache.count to zero.\n *\n * @param {DistanceOutput} output\n * @param {SimplexCache} cache\n * @param {DistanceInput} input\n */\nfunction Distance(output, cache, input) {\n  ++stats.gjkCalls;\n\n  var proxyA = input.proxyA;\n  var proxyB = input.proxyB;\n  var xfA = input.transformA;\n  var xfB = input.transformB;\n\n  // Initialize the simplex.\n  var simplex = new Simplex();\n  simplex.readCache(cache, proxyA, xfA, proxyB, xfB);\n\n  // Get simplex vertices as an array.\n  var vertices = simplex.m_v;// SimplexVertex\n  var k_maxIters = Settings.maxDistnceIterations;\n\n  // These store the vertices of the last simplex so that we\n  // can check for duplicates and prevent cycling.\n  var saveA = [];\n  var saveB = []; // int[3]\n  var saveCount = 0;\n\n  var distanceSqr1 = Infinity;\n  var distanceSqr2 = Infinity;\n\n  // Main iteration loop.\n  var iter = 0;\n  while (iter < k_maxIters) {\n    // Copy simplex so we can identify duplicates.\n    saveCount = simplex.m_count;\n    for (var i = 0; i < saveCount; ++i) {\n      saveA[i] = vertices[i].indexA;\n      saveB[i] = vertices[i].indexB;\n    }\n\n    simplex.solve();\n\n    // If we have 3 points, then the origin is in the corresponding triangle.\n    if (simplex.m_count == 3) {\n      break;\n    }\n\n    // Compute closest point.\n    var p = simplex.getClosestPoint();\n    distanceSqr2 = p.lengthSquared();\n\n    // Ensure progress\n    if (distanceSqr2 >= distanceSqr1) {\n      // break;\n    }\n    distanceSqr1 = distanceSqr2;\n\n    // Get search direction.\n    var d = simplex.getSearchDirection();\n\n    // Ensure the search direction is numerically fit.\n    if (d.lengthSquared() < Math.EPSILON * Math.EPSILON) {\n      // The origin is probably contained by a line segment\n      // or triangle. Thus the shapes are overlapped.\n\n      // We can't return zero here even though there may be overlap.\n      // In case the simplex is a point, segment, or triangle it is difficult\n      // to determine if the origin is contained in the CSO or very close to it.\n      break;\n    }\n\n    // Compute a tentative new simplex vertex using support points.\n    var vertex = vertices[simplex.m_count]; // SimplexVertex\n\n    vertex.indexA = proxyA.getSupport(Rot.mulTVec2(xfA.q, Vec2.neg(d)));\n    vertex.wA = Transform.mulVec2(xfA, proxyA.getVertex(vertex.indexA));\n\n    vertex.indexB = proxyB.getSupport(Rot.mulTVec2(xfB.q, d));\n    vertex.wB = Transform.mulVec2(xfB, proxyB.getVertex(vertex.indexB));\n\n    vertex.w = Vec2.sub(vertex.wB, vertex.wA);\n\n    // Iteration count is equated to the number of support point calls.\n    ++iter;\n    ++stats.gjkIters;\n\n    // Check for duplicate support points. This is the main termination\n    // criteria.\n    var duplicate = false;\n    for (var i = 0; i < saveCount; ++i) {\n      if (vertex.indexA == saveA[i] && vertex.indexB == saveB[i]) {\n        duplicate = true;\n        break;\n      }\n    }\n\n    // If we found a duplicate support point we must exit to avoid cycling.\n    if (duplicate) {\n      break;\n    }\n\n    // New vertex is ok and needed.\n    ++simplex.m_count;\n  }\n\n  stats.gjkMaxIters = Math.max(stats.gjkMaxIters, iter);\n\n  // Prepare output.\n  simplex.getWitnessPoints(output.pointA, output.pointB);\n  output.distance = Vec2.distance(output.pointA, output.pointB);\n  output.iterations = iter;\n\n  // Cache the simplex.\n  simplex.writeCache(cache);\n\n  // Apply radii if requested.\n  if (input.useRadii) {\n    var rA = proxyA.m_radius;\n    var rB = proxyB.m_radius;\n\n    if (output.distance > rA + rB && output.distance > Math.EPSILON) {\n      // Shapes are still no overlapped.\n      // Move the witness points to the outer surface.\n      output.distance -= rA + rB;\n      var normal = Vec2.sub(output.pointB, output.pointA);\n      normal.normalize();\n      output.pointA.addMul(rA, normal);\n      output.pointB.subMul(rB, normal);\n    } else {\n      // Shapes are overlapped when radii are considered.\n      // Move the witness points to the middle.\n      var p = Vec2.mid(output.pointA, output.pointB);\n      output.pointA.set(p);\n      output.pointB.set(p);\n      output.distance = 0.0;\n    }\n  }\n}\n\n/**\n * A distance proxy is used by the GJK algorithm. It encapsulates any shape.\n */\nfunction DistanceProxy() {\n  this.m_buffer = []; // Vec2[2]\n  this.m_vertices = []; // Vec2[]\n  this.m_count = 0;\n  this.m_radius = 0;\n};\n\n/**\n * Get the vertex count.\n */\nDistanceProxy.prototype.getVertexCount = function() {\n  return this.m_count;\n}\n\n/**\n * Get a vertex by index. Used by Distance.\n */\nDistanceProxy.prototype.getVertex = function(index) {\n  _ASSERT && common.assert(0 <= index && index < this.m_count);\n  return this.m_vertices[index];\n}\n\n/**\n * Get the supporting vertex index in the given direction.\n */\nDistanceProxy.prototype.getSupport = function(d) {\n  var bestIndex = 0;\n  var bestValue = Vec2.dot(this.m_vertices[0], d);\n  for (var i = 0; i < this.m_count; ++i) {\n    var value = Vec2.dot(this.m_vertices[i], d);\n    if (value > bestValue) {\n      bestIndex = i;\n      bestValue = value;\n    }\n  }\n  return bestIndex;\n}\n\n/**\n * Get the supporting vertex in the given direction.\n */\nDistanceProxy.prototype.getSupportVertex = function(d) {\n  return this.m_vertices[this.getSupport(d)];\n}\n\n/**\n * Initialize the proxy using the given shape. The shape must remain in scope\n * while the proxy is in use.\n */\nDistanceProxy.prototype.set = function(shape, index) {\n  // TODO remove, use shape instead\n  _ASSERT && common.assert(typeof shape.computeDistanceProxy === 'function');\n  shape.computeDistanceProxy(this, index);\n}\n\nfunction SimplexVertex() {\n  this.indexA; // wA index\n  this.indexB; // wB index\n  this.wA = Vec2.zero(); // support point in proxyA\n  this.wB = Vec2.zero(); // support point in proxyB\n  this.w = Vec2.zero(); // wB - wA\n  this.a; // barycentric coordinate for closest point\n};\n\nSimplexVertex.prototype.set = function(v) {\n  this.indexA = v.indexA;\n  this.indexB = v.indexB;\n  this.wA = Vec2.clone(v.wA);\n  this.wB = Vec2.clone(v.wB);\n  this.w = Vec2.clone(v.w);\n  this.a = v.a;\n};\n\nfunction Simplex() {\n  this.m_v1 = new SimplexVertex();\n  this.m_v2 = new SimplexVertex();\n  this.m_v3 = new SimplexVertex();\n  this.m_v = [ this.m_v1, this.m_v2, this.m_v3 ];\n  this.m_count;\n};\n\nSimplex.prototype.print = function() {\n  if (this.m_count == 3) {\n    return [\"+\" + this.m_count,\n      this.m_v1.a, this.m_v1.wA.x, this.m_v1.wA.y, this.m_v1.wB.x, this.m_v1.wB.y,\n      this.m_v2.a, this.m_v2.wA.x, this.m_v2.wA.y, this.m_v2.wB.x, this.m_v2.wB.y,\n      this.m_v3.a, this.m_v3.wA.x, this.m_v3.wA.y, this.m_v3.wB.x, this.m_v3.wB.y\n    ].toString();\n\n  } else if (this.m_count == 2) {\n    return [\"+\" + this.m_count,\n      this.m_v1.a, this.m_v1.wA.x, this.m_v1.wA.y, this.m_v1.wB.x, this.m_v1.wB.y,\n      this.m_v2.a, this.m_v2.wA.x, this.m_v2.wA.y, this.m_v2.wB.x, this.m_v2.wB.y\n    ].toString();\n\n  } else if (this.m_count == 1) {\n    return [\"+\" + this.m_count,\n      this.m_v1.a, this.m_v1.wA.x, this.m_v1.wA.y, this.m_v1.wB.x, this.m_v1.wB.y\n    ].toString();\n\n  } else {\n    return \"+\" + this.m_count;\n  }\n};\n\n// (SimplexCache, DistanceProxy, ...)\nSimplex.prototype.readCache = function(cache, proxyA, transformA, proxyB, transformB) {\n  _ASSERT && common.assert(cache.count <= 3);\n\n  // Copy data from cache.\n  this.m_count = cache.count;\n  for (var i = 0; i < this.m_count; ++i) {\n    var v = this.m_v[i];\n    v.indexA = cache.indexA[i];\n    v.indexB = cache.indexB[i];\n    var wALocal = proxyA.getVertex(v.indexA);\n    var wBLocal = proxyB.getVertex(v.indexB);\n    v.wA = Transform.mulVec2(transformA, wALocal);\n    v.wB = Transform.mulVec2(transformB, wBLocal);\n    v.w = Vec2.sub(v.wB, v.wA);\n    v.a = 0.0;\n  }\n\n  // Compute the new simplex metric, if it is substantially different than\n  // old metric then flush the simplex.\n  if (this.m_count > 1) {\n    var metric1 = cache.metric;\n    var metric2 = this.getMetric();\n    if (metric2 < 0.5 * metric1 || 2.0 * metric1 < metric2\n        || metric2 < Math.EPSILON) {\n      // Reset the simplex.\n      this.m_count = 0;\n    }\n  }\n\n  // If the cache is empty or invalid...\n  if (this.m_count == 0) {\n    var v = this.m_v[0];// SimplexVertex\n    v.indexA = 0;\n    v.indexB = 0;\n    var wALocal = proxyA.getVertex(0);\n    var wBLocal = proxyB.getVertex(0);\n    v.wA = Transform.mulVec2(transformA, wALocal);\n    v.wB = Transform.mulVec2(transformB, wBLocal);\n    v.w = Vec2.sub(v.wB, v.wA);\n    v.a = 1.0;\n    this.m_count = 1;\n  }\n}\n\n// (SimplexCache)\nSimplex.prototype.writeCache = function(cache) {\n  cache.metric = this.getMetric();\n  cache.count = this.m_count;\n  for (var i = 0; i < this.m_count; ++i) {\n    cache.indexA[i] = this.m_v[i].indexA;\n    cache.indexB[i] = this.m_v[i].indexB;\n  }\n}\n\nSimplex.prototype.getSearchDirection = function() {\n  switch (this.m_count) {\n  case 1:\n    return Vec2.neg(this.m_v1.w);\n\n  case 2: {\n    var e12 = Vec2.sub(this.m_v2.w, this.m_v1.w);\n    var sgn = Vec2.cross(e12, Vec2.neg(this.m_v1.w));\n    if (sgn > 0.0) {\n      // Origin is left of e12.\n      return Vec2.cross(1.0, e12);\n    } else {\n      // Origin is right of e12.\n      return Vec2.cross(e12, 1.0);\n    }\n  }\n\n  default:\n    _ASSERT && common.assert(false);\n    return Vec2.zero();\n  }\n}\n\nSimplex.prototype.getClosestPoint = function() {\n  switch (this.m_count) {\n  case 0:\n    _ASSERT && common.assert(false);\n    return Vec2.zero();\n\n  case 1:\n    return Vec2.clone(this.m_v1.w);\n\n  case 2:\n    return Vec2.combine(this.m_v1.a, this.m_v1.w, this.m_v2.a, this.m_v2.w);\n\n  case 3:\n    return Vec2.zero();\n\n  default:\n    _ASSERT && common.assert(false);\n    return Vec2.zero();\n  }\n}\n\nSimplex.prototype.getWitnessPoints = function(pA, pB) {\n  switch (this.m_count) {\n  case 0:\n    _ASSERT && common.assert(false);\n    break;\n\n  case 1:\n    pA.set(this.m_v1.wA);\n    pB.set(this.m_v1.wB);\n    break;\n\n  case 2:\n    pA.setCombine(this.m_v1.a, this.m_v1.wA, this.m_v2.a, this.m_v2.wA);\n    pB.setCombine(this.m_v1.a, this.m_v1.wB, this.m_v2.a, this.m_v2.wB);\n    break;\n\n  case 3:\n    pA.setCombine(this.m_v1.a, this.m_v1.wA, this.m_v2.a, this.m_v2.wA);\n    pA.addMul(this.m_v3.a, this.m_v3.wA);\n    pB.set(pA);\n    break;\n\n  default:\n    _ASSERT && common.assert(false);\n    break;\n  }\n}\n\nSimplex.prototype.getMetric = function() {\n  switch (this.m_count) {\n  case 0:\n    _ASSERT && common.assert(false);\n    return 0.0;\n\n  case 1:\n    return 0.0;\n\n  case 2:\n    return Vec2.distance(this.m_v1.w, this.m_v2.w);\n\n  case 3:\n    return Vec2.cross(Vec2.sub(this.m_v2.w, this.m_v1.w), Vec2.sub(this.m_v3.w,\n        this.m_v1.w));\n\n  default:\n    _ASSERT && common.assert(false);\n    return 0.0;\n  }\n}\n\nSimplex.prototype.solve = function() {\n  switch (this.m_count) {\n  case 1:\n    break;\n\n  case 2:\n    this.solve2();\n    break;\n\n  case 3:\n    this.solve3();\n    break;\n\n  default:\n    _ASSERT && common.assert(false);\n  }\n}\n\n// Solve a line segment using barycentric coordinates.\n//\n// p = a1 * w1 + a2 * w2\n// a1 + a2 = 1\n//\n// The vector from the origin to the closest point on the line is\n// perpendicular to the line.\n// e12 = w2 - w1\n// dot(p, e) = 0\n// a1 * dot(w1, e) + a2 * dot(w2, e) = 0\n//\n// 2-by-2 linear system\n// [1 1 ][a1] = [1]\n// [w1.e12 w2.e12][a2] = [0]\n//\n// Define\n// d12_1 = dot(w2, e12)\n// d12_2 = -dot(w1, e12)\n// d12 = d12_1 + d12_2\n//\n// Solution\n// a1 = d12_1 / d12\n// a2 = d12_2 / d12\nSimplex.prototype.solve2 = function() {\n  var w1 = this.m_v1.w;\n  var w2 = this.m_v2.w;\n  var e12 = Vec2.sub(w2, w1);\n\n  // w1 region\n  var d12_2 = -Vec2.dot(w1, e12);\n  if (d12_2 <= 0.0) {\n    // a2 <= 0, so we clamp it to 0\n    this.m_v1.a = 1.0;\n    this.m_count = 1;\n    return;\n  }\n\n  // w2 region\n  var d12_1 = Vec2.dot(w2, e12);\n  if (d12_1 <= 0.0) {\n    // a1 <= 0, so we clamp it to 0\n    this.m_v2.a = 1.0;\n    this.m_count = 1;\n    this.m_v1.set(this.m_v2);\n    return;\n  }\n\n  // Must be in e12 region.\n  var inv_d12 = 1.0 / (d12_1 + d12_2);\n  this.m_v1.a = d12_1 * inv_d12;\n  this.m_v2.a = d12_2 * inv_d12;\n  this.m_count = 2;\n}\n\n// Possible regions:\n// - points[2]\n// - edge points[0]-points[2]\n// - edge points[1]-points[2]\n// - inside the triangle\nSimplex.prototype.solve3 = function() {\n  var w1 = this.m_v1.w;\n  var w2 = this.m_v2.w;\n  var w3 = this.m_v3.w;\n\n  // Edge12\n  // [1 1 ][a1] = [1]\n  // [w1.e12 w2.e12][a2] = [0]\n  // a3 = 0\n  var e12 = Vec2.sub(w2, w1);\n  var w1e12 = Vec2.dot(w1, e12);\n  var w2e12 = Vec2.dot(w2, e12);\n  var d12_1 = w2e12;\n  var d12_2 = -w1e12;\n\n  // Edge13\n  // [1 1 ][a1] = [1]\n  // [w1.e13 w3.e13][a3] = [0]\n  // a2 = 0\n  var e13 = Vec2.sub(w3, w1);\n  var w1e13 = Vec2.dot(w1, e13);\n  var w3e13 = Vec2.dot(w3, e13);\n  var d13_1 = w3e13;\n  var d13_2 = -w1e13;\n\n  // Edge23\n  // [1 1 ][a2] = [1]\n  // [w2.e23 w3.e23][a3] = [0]\n  // a1 = 0\n  var e23 = Vec2.sub(w3, w2);// Vec2\n  var w2e23 = Vec2.dot(w2, e23);\n  var w3e23 = Vec2.dot(w3, e23);\n  var d23_1 = w3e23;\n  var d23_2 = -w2e23;\n\n  // Triangle123\n  var n123 = Vec2.cross(e12, e13);\n\n  var d123_1 = n123 * Vec2.cross(w2, w3);\n  var d123_2 = n123 * Vec2.cross(w3, w1);\n  var d123_3 = n123 * Vec2.cross(w1, w2);\n\n  // w1 region\n  if (d12_2 <= 0.0 && d13_2 <= 0.0) {\n    this.m_v1.a = 1.0;\n    this.m_count = 1;\n    return;\n  }\n\n  // e12\n  if (d12_1 > 0.0 && d12_2 > 0.0 && d123_3 <= 0.0) {\n    var inv_d12 = 1.0 / (d12_1 + d12_2);\n    this.m_v1.a = d12_1 * inv_d12;\n    this.m_v2.a = d12_2 * inv_d12;\n    this.m_count = 2;\n    return;\n  }\n\n  // e13\n  if (d13_1 > 0.0 && d13_2 > 0.0 && d123_2 <= 0.0) {\n    var inv_d13 = 1.0 / (d13_1 + d13_2);\n    this.m_v1.a = d13_1 * inv_d13;\n    this.m_v3.a = d13_2 * inv_d13;\n    this.m_count = 2;\n    this.m_v2.set(this.m_v3);\n    return;\n  }\n\n  // w2 region\n  if (d12_1 <= 0.0 && d23_2 <= 0.0) {\n    this.m_v2.a = 1.0;\n    this.m_count = 1;\n    this.m_v1.set(this.m_v2);\n    return;\n  }\n\n  // w3 region\n  if (d13_1 <= 0.0 && d23_1 <= 0.0) {\n    this.m_v3.a = 1.0;\n    this.m_count = 1;\n    this.m_v1.set(this.m_v3);\n    return;\n  }\n\n  // e23\n  if (d23_1 > 0.0 && d23_2 > 0.0 && d123_1 <= 0.0) {\n    var inv_d23 = 1.0 / (d23_1 + d23_2);\n    this.m_v2.a = d23_1 * inv_d23;\n    this.m_v3.a = d23_2 * inv_d23;\n    this.m_count = 2;\n    this.m_v1.set(this.m_v3);\n    return;\n  }\n\n  // Must be in triangle123\n  var inv_d123 = 1.0 / (d123_1 + d123_2 + d123_3);\n  this.m_v1.a = d123_1 * inv_d123;\n  this.m_v2.a = d123_2 * inv_d123;\n  this.m_v3.a = d123_3 * inv_d123;\n  this.m_count = 3;\n}\n\n/**\n * Determine if two generic shapes overlap.\n */\nDistance.testOverlap = function(shapeA, indexA, shapeB, indexB, xfA, xfB) {\n  var input = new DistanceInput();\n  input.proxyA.set(shapeA, indexA);\n  input.proxyB.set(shapeB, indexB);\n  input.transformA = xfA;\n  input.transformB = xfB;\n  input.useRadii = true;\n\n  var cache = new SimplexCache();\n\n  var output = new DistanceOutput();\n  Distance(output, cache, input);\n\n  return output.distance < 10.0 * Math.EPSILON;\n}\n","/*\n * Planck.js\n * The MIT License\n * Copyright (c) 2021 Erin Catto, Ali Shakiba\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 all\n * 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 THE\n * SOFTWARE.\n */\n\nvar _DEBUG = typeof DEBUG === 'undefined' ? false : DEBUG;\nvar _ASSERT = typeof ASSERT === 'undefined' ? false : ASSERT;\n\nvar Settings = require('../Settings');\nvar common = require('../util/common');\nvar Pool = require('../util/Pool');\nvar Vec2 = require('../common/Vec2');\nvar Math = require('../common/Math');\nvar AABB = require('./AABB');\n\nmodule.exports = DynamicTree;\n\n/**\n * A node in the dynamic tree. The client does not interact with this directly.\n * \n * @prop {AABB} aabb Enlarged AABB\n * @prop {integer} height 0: leaf, -1: free node\n */\nfunction TreeNode(id) {\n  this.id = id;\n  this.aabb = new AABB();\n  this.userData = null;\n  this.parent = null;\n  this.child1 = null;\n  this.child2 = null;\n  this.height = -1;\n\n  this.toString = function() {\n    return this.id + \": \" + this.userData;\n  }\n};\n\nTreeNode.prototype.isLeaf = function() {\n  return this.child1 == null;\n}\n/**\n * A dynamic AABB tree broad-phase, inspired by Nathanael Presson's btDbvt. A\n * dynamic tree arranges data in a binary tree to accelerate queries such as\n * volume queries and ray casts. Leafs are proxies with an AABB. In the tree we\n * expand the proxy AABB by `aabbExtension` so that the proxy AABB is bigger\n * than the client object. This allows the client object to move by small\n * amounts without triggering a tree update.\n * \n * Nodes are pooled and relocatable, so we use node indices rather than\n * pointers.\n */\nfunction DynamicTree() {\n  this.m_root = null;\n  this.m_nodes = {}\n  this.m_lastProxyId = 0;\n\n  this.m_pool = new Pool({\n    create : function() {\n      return new TreeNode();\n    }\n  });\n};\n\n/**\n * Get proxy user data.\n * \n * @return the proxy user data or 0 if the id is invalid.\n */\nDynamicTree.prototype.getUserData = function(id) {\n  var node = this.m_nodes[id];\n  _ASSERT && common.assert(!!node);\n  return node.userData;\n}\n\n/**\n * Get the fat AABB for a node id.\n * \n * @return the proxy user data or 0 if the id is invalid.\n */\nDynamicTree.prototype.getFatAABB = function(id) {\n  var node = this.m_nodes[id];\n  _ASSERT && common.assert(!!node);\n  return node.aabb;\n}\n\nDynamicTree.prototype.allocateNode = function() {\n  var node = this.m_pool.allocate();\n  node.id = ++this.m_lastProxyId;\n  node.userData = null;\n  node.parent = null;\n  node.child1 = null;\n  node.child2 = null;\n  node.height = -1;\n  this.m_nodes[node.id] = node;\n  return node;\n}\n\nDynamicTree.prototype.freeNode = function(node) {\n  this.m_pool.release(node);\n  node.height = -1;\n  delete this.m_nodes[node.id];\n}\n\n/**\n * Create a proxy in the tree as a leaf node. We return the index of the node\n * instead of a pointer so that we can grow the node pool.\n * \n * Create a proxy. Provide a tight fitting AABB and a userData pointer.\n */\nDynamicTree.prototype.createProxy = function(aabb, userData) {\n  _ASSERT && common.assert(AABB.isValid(aabb))\n\n  var node = this.allocateNode()\n\n  node.aabb.set(aabb);\n\n  // Fatten the aabb.\n  AABB.extend(node.aabb, Settings.aabbExtension);\n\n  node.userData = userData;\n  node.height = 0;\n\n  this.insertLeaf(node);\n\n  return node.id;\n}\n\n/**\n * Destroy a proxy. This asserts if the id is invalid.\n */\nDynamicTree.prototype.destroyProxy = function(id) {\n  var node = this.m_nodes[id];\n\n  _ASSERT && common.assert(!!node);\n  _ASSERT && common.assert(node.isLeaf());\n\n  this.removeLeaf(node);\n  this.freeNode(node);\n}\n\n/**\n * Move a proxy with a swepted AABB. If the proxy has moved outside of its\n * fattened AABB, then the proxy is removed from the tree and re-inserted.\n * Otherwise the function returns immediately.\n * \n * @param id\n * @param aabb\n * @param {Vec2} d Displacement\n * \n * @return true if the proxy was re-inserted.\n */\nDynamicTree.prototype.moveProxy = function(id, aabb, d) {\n  _ASSERT && common.assert(AABB.isValid(aabb));\n  _ASSERT && common.assert(!d || Vec2.isValid(d));\n\n  var node = this.m_nodes[id];\n\n  _ASSERT && common.assert(!!node);\n  _ASSERT && common.assert(node.isLeaf());\n\n  if (node.aabb.contains(aabb)) {\n    return false;\n  }\n\n  this.removeLeaf(node);\n\n  node.aabb.set(aabb)\n\n  // Extend AABB.\n  aabb = node.aabb;\n  AABB.extend(aabb, Settings.aabbExtension);\n\n  // Predict AABB displacement.\n  // var d = Vec2.mul(Settings.aabbMultiplier, displacement);\n\n  if (d.x < 0.0) {\n    aabb.lowerBound.x += d.x * Settings.aabbMultiplier;\n  } else {\n    aabb.upperBound.x += d.x * Settings.aabbMultiplier;\n  }\n\n  if (d.y < 0.0) {\n    aabb.lowerBound.y += d.y * Settings.aabbMultiplier;\n  } else {\n    aabb.upperBound.y += d.y * Settings.aabbMultiplier;\n  }\n\n  this.insertLeaf(node);\n\n  return true;\n}\n\nDynamicTree.prototype.insertLeaf = function(leaf) {\n  _ASSERT && common.assert(AABB.isValid(leaf.aabb));\n\n  if (this.m_root == null) {\n    this.m_root = leaf;\n    this.m_root.parent = null;\n    return;\n  }\n\n  // Find the best sibling for this node\n  var leafAABB = leaf.aabb;\n  var index = this.m_root;\n  while (index.isLeaf() == false) {\n    var child1 = index.child1;\n    var child2 = index.child2;\n\n    var area = index.aabb.getPerimeter();\n\n    var combinedAABB = new AABB();\n    combinedAABB.combine(index.aabb, leafAABB);\n    var combinedArea = combinedAABB.getPerimeter();\n\n    // Cost of creating a new parent for this node and the new leaf\n    var cost = 2.0 * combinedArea;\n\n    // Minimum cost of pushing the leaf further down the tree\n    var inheritanceCost = 2.0 * (combinedArea - area);\n\n    // Cost of descending into child1\n    var cost1;\n    if (child1.isLeaf()) {\n      var aabb = new AABB();\n      aabb.combine(leafAABB, child1.aabb);\n      cost1 = aabb.getPerimeter() + inheritanceCost;\n    } else {\n      var aabb = new AABB();\n      aabb.combine(leafAABB, child1.aabb);\n      var oldArea = child1.aabb.getPerimeter();\n      var newArea = aabb.getPerimeter();\n      cost1 = (newArea - oldArea) + inheritanceCost;\n    }\n\n    // Cost of descending into child2\n    var cost2;\n    if (child2.isLeaf()) {\n      var aabb = new AABB();\n      aabb.combine(leafAABB, child2.aabb);\n      cost2 = aabb.getPerimeter() + inheritanceCost;\n    } else {\n      var aabb = new AABB();\n      aabb.combine(leafAABB, child2.aabb);\n      var oldArea = child2.aabb.getPerimeter();\n      var newArea = aabb.getPerimeter();\n      cost2 = newArea - oldArea + inheritanceCost;\n    }\n\n    // Descend according to the minimum cost.\n    if (cost < cost1 && cost < cost2) {\n      break;\n    }\n\n    // Descend\n    if (cost1 < cost2) {\n      index = child1;\n    } else {\n      index = child2;\n    }\n  }\n\n  var sibling = index;\n\n  // Create a new parent.\n  var oldParent = sibling.parent;\n  var newParent = this.allocateNode();\n  newParent.parent = oldParent;\n  newParent.userData = null;\n  newParent.aabb.combine(leafAABB, sibling.aabb);\n  newParent.height = sibling.height + 1;\n\n  if (oldParent != null) {\n    // The sibling was not the root.\n    if (oldParent.child1 == sibling) {\n      oldParent.child1 = newParent;\n    } else {\n      oldParent.child2 = newParent;\n    }\n\n    newParent.child1 = sibling;\n    newParent.child2 = leaf;\n    sibling.parent = newParent;\n    leaf.parent = newParent;\n  } else {\n    // The sibling was the root.\n    newParent.child1 = sibling;\n    newParent.child2 = leaf;\n    sibling.parent = newParent;\n    leaf.parent = newParent;\n    this.m_root = newParent;\n  }\n\n  // Walk back up the tree fixing heights and AABBs\n  index = leaf.parent;\n  while (index != null) {\n    index = this.balance(index);\n\n    var child1 = index.child1;\n    var child2 = index.child2;\n\n    _ASSERT && common.assert(child1 != null);\n    _ASSERT && common.assert(child2 != null);\n\n    index.height = 1 + Math.max(child1.height, child2.height);\n    index.aabb.combine(child1.aabb, child2.aabb);\n\n    index = index.parent;\n  }\n\n  // validate();\n}\n\nDynamicTree.prototype.removeLeaf = function(leaf) {\n  if (leaf == this.m_root) {\n    this.m_root = null;\n    return;\n  }\n\n  var parent = leaf.parent;\n  var grandParent = parent.parent;\n  var sibling;\n  if (parent.child1 == leaf) {\n    sibling = parent.child2;\n  } else {\n    sibling = parent.child1;\n  }\n\n  if (grandParent != null) {\n    // Destroy parent and connect sibling to grandParent.\n    if (grandParent.child1 == parent) {\n      grandParent.child1 = sibling;\n    } else {\n      grandParent.child2 = sibling;\n    }\n    sibling.parent = grandParent;\n    this.freeNode(parent);\n\n    // Adjust ancestor bounds.\n    var index = grandParent;\n    while (index != null) {\n      index = this.balance(index);\n\n      var child1 = index.child1;\n      var child2 = index.child2;\n\n      index.aabb.combine(child1.aabb, child2.aabb);\n      index.height = 1 + Math.max(child1.height, child2.height);\n\n      index = index.parent;\n    }\n  } else {\n    this.m_root = sibling;\n    sibling.parent = null;\n    this.freeNode(parent);\n  }\n\n  // validate();\n}\n\n/**\n * Perform a left or right rotation if node A is imbalanced. Returns the new\n * root index.\n */\nDynamicTree.prototype.balance = function(iA) {\n  _ASSERT && common.assert(iA != null);\n\n  var A = iA;\n  if (A.isLeaf() || A.height < 2) {\n    return iA;\n  }\n\n  var B = A.child1;\n  var C = A.child2;\n\n  var balance = C.height - B.height;\n\n  // Rotate C up\n  if (balance > 1) {\n    var F = C.child1;\n    var G = C.child2;\n\n    // Swap A and C\n    C.child1 = A;\n    C.parent = A.parent;\n    A.parent = C;\n\n    // A's old parent should point to C\n    if (C.parent != null) {\n      if (C.parent.child1 == iA) {\n        C.parent.child1 = C;\n      } else {\n        C.parent.child2 = C;\n      }\n    } else {\n      this.m_root = C;\n    }\n\n    // Rotate\n    if (F.height > G.height) {\n      C.child2 = F;\n      A.child2 = G;\n      G.parent = A;\n      A.aabb.combine(B.aabb, G.aabb);\n      C.aabb.combine(A.aabb, F.aabb);\n\n      A.height = 1 + Math.max(B.height, G.height);\n      C.height = 1 + Math.max(A.height, F.height);\n    } else {\n      C.child2 = G;\n      A.child2 = F;\n      F.parent = A;\n      A.aabb.combine(B.aabb, F.aabb);\n      C.aabb.combine(A.aabb, G.aabb);\n\n      A.height = 1 + Math.max(B.height, F.height);\n      C.height = 1 + Math.max(A.height, G.height);\n    }\n\n    return C;\n  }\n\n  // Rotate B up\n  if (balance < -1) {\n    var D = B.child1;\n    var E = B.child2;\n\n    // Swap A and B\n    B.child1 = A;\n    B.parent = A.parent;\n    A.parent = B;\n\n    // A's old parent should point to B\n    if (B.parent != null) {\n      if (B.parent.child1 == A) {\n        B.parent.child1 = B;\n      } else {\n        B.parent.child2 = B;\n      }\n    } else {\n      this.m_root = B;\n    }\n\n    // Rotate\n    if (D.height > E.height) {\n      B.child2 = D;\n      A.child1 = E;\n      E.parent = A;\n      A.aabb.combine(C.aabb, E.aabb);\n      B.aabb.combine(A.aabb, D.aabb);\n\n      A.height = 1 + Math.max(C.height, E.height);\n      B.height = 1 + Math.max(A.height, D.height);\n    } else {\n      B.child2 = E;\n      A.child1 = D;\n      D.parent = A;\n      A.aabb.combine(C.aabb, D.aabb);\n      B.aabb.combine(A.aabb, E.aabb);\n\n      A.height = 1 + Math.max(C.height, D.height);\n      B.height = 1 + Math.max(A.height, E.height);\n    }\n\n    return B;\n  }\n\n  return A;\n}\n\n/**\n * Compute the height of the binary tree in O(N) time. Should not be called\n * often.\n */\nDynamicTree.prototype.getHeight = function() {\n  if (this.m_root == null) {\n    return 0;\n  }\n\n  return this.m_root.height;\n}\n\n/**\n * Get the ratio of the sum of the node areas to the root area.\n */\nDynamicTree.prototype.getAreaRatio = function() {\n  if (this.m_root == null) {\n    return 0.0;\n  }\n\n  var root = this.m_root;\n  var rootArea = root.aabb.getPerimeter();\n\n  var totalArea = 0.0;\n  var node, it = iteratorPool.allocate().preorder(this.m_root);\n  while (node = it.next()) {\n    if (node.height < 0) {\n      // Free node in pool\n      continue;\n    }\n\n    totalArea += node.aabb.getPerimeter();\n  }\n\n  iteratorPool.release(it);\n\n  return totalArea / rootArea;\n}\n\n/**\n * Compute the height of a sub-tree.\n */\nDynamicTree.prototype.computeHeight = function(id) {\n  var node;\n  if (typeof id !== 'undefined') {\n    node = this.m_nodes[id];\n  } else {\n    node = this.m_root;\n  }\n\n  // _ASSERT && common.assert(0 <= id && id < this.m_nodeCapacity);\n\n  if (node.isLeaf()) {\n    return 0;\n  }\n\n  var height1 = this.computeHeight(node.child1.id);\n  var height2 = this.computeHeight(node.child2.id);\n  return 1 + Math.max(height1, height2);\n}\n\nDynamicTree.prototype.validateStructure = function(node) {\n  if (node == null) {\n    return;\n  }\n\n  if (node == this.m_root) {\n    _ASSERT && common.assert(node.parent == null);\n  }\n\n  var child1 = node.child1;\n  var child2 = node.child2;\n\n  if (node.isLeaf()) {\n    _ASSERT && common.assert(child1 == null);\n    _ASSERT && common.assert(child2 == null);\n    _ASSERT && common.assert(node.height == 0);\n    return;\n  }\n\n  // _ASSERT && common.assert(0 <= child1 && child1 < this.m_nodeCapacity);\n  // _ASSERT && common.assert(0 <= child2 && child2 < this.m_nodeCapacity);\n\n  _ASSERT && common.assert(child1.parent == node);\n  _ASSERT && common.assert(child2.parent == node);\n\n  this.validateStructure(child1);\n  this.validateStructure(child2);\n}\n\nDynamicTree.prototype.validateMetrics = function(node) {\n  if (node == null) {\n    return;\n  }\n\n  var child1 = node.child1;\n  var child2 = node.child2;\n\n  if (node.isLeaf()) {\n    _ASSERT && common.assert(child1 == null);\n    _ASSERT && common.assert(child2 == null);\n    _ASSERT && common.assert(node.height == 0);\n    return;\n  }\n\n  // _ASSERT && common.assert(0 <= child1 && child1 < this.m_nodeCapacity);\n  // _ASSERT && common.assert(0 <= child2 && child2 < this.m_nodeCapacity);\n\n  var height1 = child1.height;\n  var height2 = child2.height;\n  var height = 1 + Math.max(height1, height2);\n  _ASSERT && common.assert(node.height == height);\n\n  var aabb = new AABB();\n  aabb.combine(child1.aabb, child2.aabb);\n\n  _ASSERT && common.assert(AABB.areEqual(aabb, node.aabb));\n\n  this.validateMetrics(child1);\n  this.validateMetrics(child2);\n}\n\n// Validate this tree. For testing.\nDynamicTree.prototype.validate = function() {\n  this.validateStructure(this.m_root);\n  this.validateMetrics(this.m_root);\n\n  _ASSERT && common.assert(this.getHeight() == this.computeHeight());\n}\n\n/**\n * Get the maximum balance of an node in the tree. The balance is the difference\n * in height of the two children of a node.\n */\nDynamicTree.prototype.getMaxBalance = function() {\n  var maxBalance = 0;\n  var node, it = iteratorPool.allocate().preorder(this.m_root);\n  while (node = it.next()) {\n    if (node.height <= 1) {\n      continue;\n    }\n\n    _ASSERT && common.assert(node.isLeaf() == false);\n\n    var balance = Math.abs(node.child2.height - node.child1.height);\n    maxBalance = Math.max(maxBalance, balance);\n  }\n  iteratorPool.release(it);\n\n  return maxBalance;\n}\n\n/**\n * Build an optimal tree. Very expensive. For testing.\n */\nDynamicTree.prototype.rebuildBottomUp = function() {\n  var nodes = [];\n  var count = 0;\n\n  // Build array of leaves. Free the rest.\n  var node, it = iteratorPool.allocate().preorder(this.m_root);\n  while (node = it.next()) {\n    if (node.height < 0) {\n      // free node in pool\n      continue;\n    }\n\n    if (node.isLeaf()) {\n      node.parent = null;\n      nodes[count] = node;\n      ++count;\n    } else {\n      this.freeNode(node);\n    }\n  }\n  iteratorPool.release(it);\n\n  while (count > 1) {\n    var minCost = Infinity;\n    var iMin = -1, jMin = -1;\n    for (var i = 0; i < count; ++i) {\n      var aabbi = nodes[i].aabb;\n      for (var j = i + 1; j < count; ++j) {\n        var aabbj = nodes[j].aabb;\n        var b = new AABB();\n        b.combine(aabbi, aabbj);\n        var cost = b.getPerimeter();\n        if (cost < minCost) {\n          iMin = i;\n          jMin = j;\n          minCost = cost;\n        }\n      }\n    }\n\n    var child1 = nodes[iMin];\n    var child2 = nodes[jMin];\n\n    var parent = this.allocateNode();\n    parent.child1 = child1;\n    parent.child2 = child2;\n    parent.height = 1 + Math.max(child1.height, child2.height);\n    parent.aabb.combine(child1.aabb, child2.aabb);\n    parent.parent = null;\n\n    child1.parent = parent;\n    child2.parent = parent;\n\n    nodes[jMin] = nodes[count - 1];\n    nodes[iMin] = parent;\n    --count;\n  }\n\n  this.m_root = nodes[0];\n\n  this.validate();\n}\n\n/**\n * Shift the world origin. Useful for large worlds. The shift formula is:\n * position -= newOrigin\n * \n * @param newOrigin The new origin with respect to the old origin\n */\nDynamicTree.prototype.shiftOrigin = function(newOrigin) {\n  // Build array of leaves. Free the rest.\n  var node, it = iteratorPool.allocate().preorder(this.m_root);\n  while (node = it.next()) {\n    var aabb = node.aabb;\n    aabb.lowerBound.x -= newOrigin.x;\n    aabb.lowerBound.y -= newOrigin.y;\n    aabb.upperBound.x -= newOrigin.x;\n    aabb.upperBound.y -= newOrigin.y;\n  }\n  iteratorPool.release(it);\n}\n\n/**\n * @function {DynamicTree~queryCallback}\n * \n * @param id Node id.\n */\n\n/**\n * Query an AABB for overlapping proxies. The callback class is called for each\n * proxy that overlaps the supplied AABB.\n * \n * @param {DynamicTree~queryCallback} queryCallback\n */\nDynamicTree.prototype.query = function(aabb, queryCallback) {\n  _ASSERT && common.assert(typeof queryCallback === 'function')\n  var stack = stackPool.allocate();\n\n  stack.push(this.m_root);\n  while (stack.length > 0) {\n    var node = stack.pop();\n    if (node == null) {\n      continue;\n    }\n\n    if (AABB.testOverlap(node.aabb, aabb)) {\n      if (node.isLeaf()) {\n        var proceed = queryCallback(node.id);\n        if (proceed == false) {\n          return;\n        }\n      } else {\n        stack.push(node.child1);\n        stack.push(node.child2);\n      }\n    }\n  }\n\n  stackPool.release(stack);\n}\n\n/**\n * Ray-cast against the proxies in the tree. This relies on the callback to\n * perform a exact ray-cast in the case were the proxy contains a shape. The\n * callback also performs the any collision filtering. This has performance\n * roughly equal to k * log(n), where k is the number of collisions and n is the\n * number of proxies in the tree.\n * \n * @param input The ray-cast input data. The ray extends from p1 to p1 +\n *          maxFraction * (p2 - p1).\n * @param rayCastCallback A function that is called for each proxy that is hit by\n *          the ray.\n */\nDynamicTree.prototype.rayCast = function(input, rayCastCallback) { // TODO GC\n  _ASSERT && common.assert(typeof rayCastCallback === 'function')\n  var p1 = input.p1;\n  var p2 = input.p2;\n  var r = Vec2.sub(p2, p1);\n  _ASSERT && common.assert(r.lengthSquared() > 0.0);\n  r.normalize();\n\n  // v is perpendicular to the segment.\n  var v = Vec2.cross(1.0, r);\n  var abs_v = Vec2.abs(v);\n\n  // Separating axis for segment (Gino, p80).\n  // |dot(v, p1 - c)| > dot(|v|, h)\n\n  var maxFraction = input.maxFraction;\n\n  // Build a bounding box for the segment.\n  var segmentAABB = new AABB();\n  var t = Vec2.combine((1 - maxFraction), p1, maxFraction, p2);\n  segmentAABB.combinePoints(p1, t);\n\n  var stack = stackPool.allocate();\n  var subInput = inputPool.allocate();\n\n  stack.push(this.m_root);\n  while (stack.length > 0) {\n    var node = stack.pop();\n    if (node == null) {\n      continue;\n    }\n\n    if (AABB.testOverlap(node.aabb, segmentAABB) == false) {\n      continue;\n    }\n\n    // Separating axis for segment (Gino, p80).\n    // |dot(v, p1 - c)| > dot(|v|, h)\n    var c = node.aabb.getCenter();\n    var h = node.aabb.getExtents();\n    var separation = Math.abs(Vec2.dot(v, Vec2.sub(p1, c)))\n        - Vec2.dot(abs_v, h);\n    if (separation > 0.0) {\n      continue;\n    }\n\n    if (node.isLeaf()) {\n      subInput.p1 = Vec2.clone(input.p1);\n      subInput.p2 = Vec2.clone(input.p2);\n      subInput.maxFraction = maxFraction;\n\n      var value = rayCastCallback(subInput, node.id);\n\n      if (value == 0.0) {\n        // The client has terminated the ray cast.\n        return;\n      }\n\n      if (value > 0.0) {\n        // update segment bounding box.\n        maxFraction = value;\n        t = Vec2.combine((1 - maxFraction), p1, maxFraction, p2);\n        segmentAABB.combinePoints(p1, t);\n      }\n    } else {\n      stack.push(node.child1);\n      stack.push(node.child2);\n    }\n  }\n\n  stackPool.release(stack);\n  inputPool.release(subInput);\n}\n\nvar inputPool = new Pool({\n  create : function() {\n    return {};\n  },\n  release : function(stack) {\n  }\n});\n\nvar stackPool = new Pool({\n  create : function() {\n    return [];\n  },\n  release : function(stack) {\n    stack.length = 0;\n  }\n});\n\nvar iteratorPool = new Pool({\n  create : function() {\n    return new Iterator();\n  },\n  release : function(iterator) {\n    iterator.close();\n  }\n});\n\nfunction Iterator() {\n  var parents = [];\n  var states = [];\n  return {\n    preorder : function(root) {\n      parents.length = 0;\n      parents.push(root);\n      states.length = 0;\n      states.push(0);\n      return this;\n    },\n    next : function() {\n      while (parents.length > 0) {\n        var i = parents.length - 1;\n        var node = parents[i];\n        if (states[i] === 0) {\n          states[i] = 1;\n          return node;\n        }\n        if (states[i] === 1) {\n          states[i] = 2;\n          if (node.child1) {\n            parents.push(node.child1);\n            states.push(1);\n            return node.child1;\n          }\n        }\n        if (states[i] === 2) {\n          states[i] = 3;\n          if (node.child2) {\n            parents.push(node.child2);\n            states.push(1);\n            return node.child2;\n          }\n        }\n        parents.pop();\n        states.pop();\n      }\n    },\n    close : function() {\n      parents.length = 0;\n    }\n  };\n}\n","/*\n * Planck.js\n * The MIT License\n * Copyright (c) 2021 Erin Catto, Ali Shakiba\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 all\n * 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 THE\n * SOFTWARE.\n */\n\nvar _DEBUG = typeof DEBUG === 'undefined' ? false : DEBUG;\nvar _ASSERT = typeof ASSERT === 'undefined' ? false : ASSERT;\n\nmodule.exports = TimeOfImpact;\nmodule.exports.Input = TOIInput;\nmodule.exports.Output = TOIOutput;\n\nvar Settings = require('../Settings');\n\nvar common = require('../util/common');\nvar Timer = require('../util/Timer');\n\nvar stats = require('../common/stats');\n\nvar Math = require('../common/Math');\nvar Vec2 = require('../common/Vec2');\nvar Vec3 = require('../common/Vec3');\nvar Mat22 = require('../common/Mat22');\nvar Mat33 = require('../common/Mat33');\nvar Rot = require('../common/Rot');\nvar Sweep = require('../common/Sweep');\nvar Transform = require('../common/Transform');\nvar Velocity = require('../common/Velocity');\nvar Position = require('../common/Position');\n\nvar Distance = require('./Distance');\nvar DistanceInput = Distance.Input;\nvar DistanceOutput = Distance.Output;\nvar DistanceProxy = Distance.Proxy;\nvar SimplexCache = Distance.Cache;\n\n/**\n * Input parameters for TimeOfImpact.\n * \n * @prop {DistanceProxy} proxyA\n * @prop {DistanceProxy} proxyB\n * @prop {Sweep} sweepA\n * @prop {Sweep} sweepB\n * @prop tMax defines sweep interval [0, tMax]\n */\nfunction TOIInput() {\n  this.proxyA = new DistanceProxy();\n  this.proxyB = new DistanceProxy();\n  this.sweepA = new Sweep();\n  this.sweepB = new Sweep();\n  this.tMax;\n};\n\n// TOIOutput State\nTOIOutput.e_unknown = 0;\nTOIOutput.e_failed = 1;\nTOIOutput.e_overlapped = 2;\nTOIOutput.e_touching = 3;\nTOIOutput.e_separated = 4;\n\n/**\n * Output parameters for TimeOfImpact.\n * \n * @prop state\n * @prop t\n */\nfunction TOIOutput() {\n  this.state;\n  this.t;\n};\n\nstats.toiTime = 0;\nstats.toiMaxTime = 0;\nstats.toiCalls = 0;\nstats.toiIters = 0;\nstats.toiMaxIters = 0;\nstats.toiRootIters = 0;\nstats.toiMaxRootIters = 0;\n\n/**\n * Compute the upper bound on time before two shapes penetrate. Time is\n * represented as a fraction between [0,tMax]. This uses a swept separating axis\n * and may miss some intermediate, non-tunneling collision. If you change the\n * time interval, you should call this function again.\n * \n * Note: use Distance to compute the contact point and normal at the time of\n * impact.\n * \n * CCD via the local separating axis method. This seeks progression by computing\n * the largest time at which separation is maintained.\n */\nfunction TimeOfImpact(output, input) {\n  var timer = Timer.now();\n\n  ++stats.toiCalls;\n\n  output.state = TOIOutput.e_unknown;\n  output.t = input.tMax;\n\n  var proxyA = input.proxyA; // DistanceProxy\n  var proxyB = input.proxyB; // DistanceProxy\n\n  var sweepA = input.sweepA; // Sweep\n  var sweepB = input.sweepB; // Sweep\n\n  // Large rotations can make the root finder fail, so we normalize the\n  // sweep angles.\n  sweepA.normalize();\n  sweepB.normalize();\n\n  var tMax = input.tMax;\n\n  var totalRadius = proxyA.m_radius + proxyB.m_radius;\n  var target = Math.max(Settings.linearSlop, totalRadius - 3.0 * Settings.linearSlop);\n  var tolerance = 0.25 * Settings.linearSlop;\n  _ASSERT && common.assert(target > tolerance);\n\n  var t1 = 0.0;\n  var k_maxIterations = Settings.maxTOIIterations;\n  var iter = 0;\n\n  // Prepare input for distance query.\n  var cache = new SimplexCache();\n\n  var distanceInput = new DistanceInput();\n  distanceInput.proxyA = input.proxyA;\n  distanceInput.proxyB = input.proxyB;\n  distanceInput.useRadii = false;\n\n  // The outer loop progressively attempts to compute new separating axes.\n  // This loop terminates when an axis is repeated (no progress is made).\n  for (;;) {\n    var xfA = Transform.identity();\n    var xfB = Transform.identity();\n    sweepA.getTransform(xfA, t1);\n    sweepB.getTransform(xfB, t1);\n\n    // Get the distance between shapes. We can also use the results\n    // to get a separating axis.\n    distanceInput.transformA = xfA;\n    distanceInput.transformB = xfB;\n    var distanceOutput = new DistanceOutput();\n    Distance(distanceOutput, cache, distanceInput);\n\n    // If the shapes are overlapped, we give up on continuous collision.\n    if (distanceOutput.distance <= 0.0) {\n      // Failure!\n      output.state = TOIOutput.e_overlapped;\n      output.t = 0.0;\n      break;\n    }\n\n    if (distanceOutput.distance < target + tolerance) {\n      // Victory!\n      output.state = TOIOutput.e_touching;\n      output.t = t1;\n      break;\n    }\n\n    // Initialize the separating axis.\n    var fcn = new SeparationFunction();\n    fcn.initialize(cache, proxyA, sweepA, proxyB, sweepB, t1);\n\n    // if (false) {\n    //   // Dump the curve seen by the root finder\n    //   var N = 100;\n    //   var dx = 1.0 / N;\n    //   var xs = []; // [ N + 1 ];\n    //   var fs = []; // [ N + 1 ];\n    //   var x = 0.0;\n    //   for (var i = 0; i <= N; ++i) {\n    //     sweepA.getTransform(xfA, x);\n    //     sweepB.getTransform(xfB, x);\n    //     var f = fcn.evaluate(xfA, xfB) - target;\n    //     printf(\"%g %g\\n\", x, f);\n    //     xs[i] = x;\n    //     fs[i] = f;\n    //     x += dx;\n    //   }\n    // }\n\n    // Compute the TOI on the separating axis. We do this by successively\n    // resolving the deepest point. This loop is bounded by the number of\n    // vertices.\n    var done = false;\n    var t2 = tMax;\n    var pushBackIter = 0;\n    for (;;) {\n      // Find the deepest point at t2. Store the witness point indices.\n      var s2 = fcn.findMinSeparation(t2);\n      var indexA = fcn.indexA;\n      var indexB = fcn.indexB;\n\n      // Is the final configuration separated?\n      if (s2 > target + tolerance) {\n        // Victory!\n        output.state = TOIOutput.e_separated;\n        output.t = tMax;\n        done = true;\n        break;\n      }\n\n      // Has the separation reached tolerance?\n      if (s2 > target - tolerance) {\n        // Advance the sweeps\n        t1 = t2;\n        break;\n      }\n\n      // Compute the initial separation of the witness points.\n      var s1 = fcn.evaluate(t1);\n      var indexA = fcn.indexA;\n      var indexB = fcn.indexB;\n\n      // Check for initial overlap. This might happen if the root finder\n      // runs out of iterations.\n      if (s1 < target - tolerance) {\n        output.state = TOIOutput.e_failed;\n        output.t = t1;\n        done = true;\n        break;\n      }\n\n      // Check for touching\n      if (s1 <= target + tolerance) {\n        // Victory! t1 should hold the TOI (could be 0.0).\n        output.state = TOIOutput.e_touching;\n        output.t = t1;\n        done = true;\n        break;\n      }\n\n      // Compute 1D root of: f(x) - target = 0\n      var rootIterCount = 0;\n      var a1 = t1, a2 = t2;\n      for (;;) {\n        // Use a mix of the secant rule and bisection.\n        var t;\n        if (rootIterCount & 1) {\n          // Secant rule to improve convergence.\n          t = a1 + (target - s1) * (a2 - a1) / (s2 - s1);\n        } else {\n          // Bisection to guarantee progress.\n          t = 0.5 * (a1 + a2);\n        }\n\n        ++rootIterCount;\n        ++stats.toiRootIters;\n\n        var s = fcn.evaluate(t);\n        var indexA = fcn.indexA;\n        var indexB = fcn.indexB;\n\n        if (Math.abs(s - target) < tolerance) {\n          // t2 holds a tentative value for t1\n          t2 = t;\n          break;\n        }\n\n        // Ensure we continue to bracket the root.\n        if (s > target) {\n          a1 = t;\n          s1 = s;\n        } else {\n          a2 = t;\n          s2 = s;\n        }\n\n        if (rootIterCount == 50) {\n          break;\n        }\n      }\n\n      stats.toiMaxRootIters = Math.max(stats.toiMaxRootIters, rootIterCount);\n\n      ++pushBackIter;\n\n      if (pushBackIter == Settings.maxPolygonVertices) {\n        break;\n      }\n    }\n\n    ++iter;\n    ++stats.toiIters;\n\n    if (done) {\n      break;\n    }\n\n    if (iter == k_maxIterations) {\n      // Root finder got stuck. Semi-victory.\n      output.state = TOIOutput.e_failed;\n      output.t = t1;\n      break;\n    }\n  }\n\n  stats.toiMaxIters = Math.max(stats.toiMaxIters, iter);\n\n  var time = Timer.diff(timer);\n  stats.toiMaxTime = Math.max(stats.toiMaxTime, time);\n  stats.toiTime += time;\n}\n\n// SeparationFunction Type\nvar e_points = 1;\nvar e_faceA = 2;\nvar e_faceB = 3;\n\nfunction SeparationFunction() {\n  this.m_proxyA = new DistanceProxy();\n  this.m_proxyB = new DistanceProxy();\n  this.m_sweepA;// Sweep\n  this.m_sweepB;// Sweep\n  this.indexA;// integer\n  this.indexB;// integer\n  this.m_type;\n  this.m_localPoint = Vec2.zero();\n  this.m_axis = Vec2.zero();\n};\n\n// TODO_ERIN might not need to return the separation\n\n/**\n * @param {SimplexCache} cache\n * @param {DistanceProxy} proxyA\n * @param {Sweep} sweepA\n * @param {DistanceProxy} proxyB\n * @param {Sweep} sweepB\n * @param {float} t1\n */\nSeparationFunction.prototype.initialize = function(cache, proxyA, sweepA, proxyB, sweepB, t1) {\n  this.m_proxyA = proxyA;\n  this.m_proxyB = proxyB;\n  var count = cache.count;\n  _ASSERT && common.assert(0 < count && count < 3);\n\n  this.m_sweepA = sweepA;\n  this.m_sweepB = sweepB;\n\n  var xfA = Transform.identity();\n  var xfB = Transform.identity();\n  this.m_sweepA.getTransform(xfA, t1);\n  this.m_sweepB.getTransform(xfB, t1);\n\n  if (count == 1) {\n    this.m_type = e_points;\n    var localPointA = this.m_proxyA.getVertex(cache.indexA[0]);\n    var localPointB = this.m_proxyB.getVertex(cache.indexB[0]);\n    var pointA = Transform.mulVec2(xfA, localPointA);\n    var pointB = Transform.mulVec2(xfB, localPointB);\n    this.m_axis.setCombine(1, pointB, -1, pointA);\n    var s = this.m_axis.normalize();\n    return s;\n\n  } else if (cache.indexA[0] == cache.indexA[1]) {\n    // Two points on B and one on A.\n    this.m_type = e_faceB;\n    var localPointB1 = proxyB.getVertex(cache.indexB[0]);\n    var localPointB2 = proxyB.getVertex(cache.indexB[1]);\n\n    this.m_axis = Vec2.cross(Vec2.sub(localPointB2, localPointB1), 1.0);\n    this.m_axis.normalize();\n    var normal = Rot.mulVec2(xfB.q, this.m_axis);\n\n    this.m_localPoint = Vec2.mid(localPointB1, localPointB2);\n    var pointB = Transform.mulVec2(xfB, this.m_localPoint);\n\n    var localPointA = proxyA.getVertex(cache.indexA[0]);\n    var pointA = Transform.mulVec2(xfA, localPointA);\n\n    var s = Vec2.dot(pointA, normal) - Vec2.dot(pointB, normal);\n    if (s < 0.0) {\n      this.m_axis = Vec2.neg(this.m_axis);\n      s = -s;\n    }\n    return s;\n\n  } else {\n    // Two points on A and one or two points on B.\n    this.m_type = e_faceA;\n    var localPointA1 = this.m_proxyA.getVertex(cache.indexA[0]);\n    var localPointA2 = this.m_proxyA.getVertex(cache.indexA[1]);\n\n    this.m_axis = Vec2.cross(Vec2.sub(localPointA2, localPointA1), 1.0);\n    this.m_axis.normalize();\n    var normal = Rot.mulVec2(xfA.q, this.m_axis);\n\n    this.m_localPoint = Vec2.mid(localPointA1, localPointA2);\n    var pointA = Transform.mulVec2(xfA, this.m_localPoint);\n\n    var localPointB = this.m_proxyB.getVertex(cache.indexB[0]);\n    var pointB = Transform.mulVec2(xfB, localPointB);\n\n    var s = Vec2.dot(pointB, normal) - Vec2.dot(pointA, normal);\n    if (s < 0.0) {\n      this.m_axis = Vec2.neg(this.m_axis);\n      s = -s;\n    }\n    return s;\n  }\n};\n\nSeparationFunction.prototype.compute = function(find, t) {\n  // It was findMinSeparation and evaluate\n  var xfA = Transform.identity();\n  var xfB = Transform.identity();\n  this.m_sweepA.getTransform(xfA, t);\n  this.m_sweepB.getTransform(xfB, t);\n\n  switch (this.m_type) {\n  case e_points: {\n    if (find) {\n      var axisA = Rot.mulTVec2(xfA.q, this.m_axis);\n      var axisB = Rot.mulTVec2(xfB.q, Vec2.neg(this.m_axis));\n\n      this.indexA = this.m_proxyA.getSupport(axisA);\n      this.indexB = this.m_proxyB.getSupport(axisB);\n    }\n\n    var localPointA = this.m_proxyA.getVertex(this.indexA);\n    var localPointB = this.m_proxyB.getVertex(this.indexB);\n\n    var pointA = Transform.mulVec2(xfA, localPointA);\n    var pointB = Transform.mulVec2(xfB, localPointB);\n\n    var sep = Vec2.dot(pointB, this.m_axis) - Vec2.dot(pointA, this.m_axis);\n    return sep;\n  }\n\n  case e_faceA: {\n    var normal = Rot.mulVec2(xfA.q, this.m_axis);\n    var pointA = Transform.mulVec2(xfA, this.m_localPoint);\n\n    if (find) {\n      var axisB = Rot.mulTVec2(xfB.q, Vec2.neg(normal));\n\n      this.indexA = -1;\n      this.indexB = this.m_proxyB.getSupport(axisB);\n    }\n\n    var localPointB = this.m_proxyB.getVertex(this.indexB);\n    var pointB = Transform.mulVec2(xfB, localPointB);\n\n    var sep = Vec2.dot(pointB, normal) - Vec2.dot(pointA, normal);\n    return sep;\n  }\n\n  case e_faceB: {\n    var normal = Rot.mulVec2(xfB.q, this.m_axis);\n    var pointB = Transform.mulVec2(xfB, this.m_localPoint);\n\n    if (find) {\n      var axisA = Rot.mulTVec2(xfA.q, Vec2.neg(normal));\n\n      this.indexB = -1;\n      this.indexA = this.m_proxyA.getSupport(axisA);\n    }\n\n    var localPointA = this.m_proxyA.getVertex(this.indexA);\n    var pointA = Transform.mulVec2(xfA, localPointA);\n\n    var sep = Vec2.dot(pointA, normal) - Vec2.dot(pointB, normal);\n    return sep;\n  }\n\n  default:\n    _ASSERT && common.assert(false);\n    if (find) {\n      this.indexA = -1;\n      this.indexB = -1;\n    }\n    return 0.0;\n  }\n};\n\nSeparationFunction.prototype.findMinSeparation = function(t) {\n  return this.compute(true, t);\n};\n\nSeparationFunction.prototype.evaluate = function(t) {\n  return this.compute(false, t);\n};\n","/*\n * Planck.js\n * The MIT License\n * Copyright (c) 2021 Erin Catto, Ali Shakiba\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 all\n * 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 THE\n * SOFTWARE.\n */\n\nvar _DEBUG = typeof DEBUG === 'undefined' ? false : DEBUG;\nvar _ASSERT = typeof ASSERT === 'undefined' ? false : ASSERT;\n\nmodule.exports = Mat22;\n\nvar common = require('../util/common');\nvar Math = require('./Math');\nvar Vec2 = require('./Vec2');\n\n/**\n * A 2-by-2 matrix. Stored in column-major order.\n */\nfunction Mat22(a, b, c, d) {\n  if (typeof a === 'object' && a !== null) {\n    this.ex = Vec2.clone(a);\n    this.ey = Vec2.clone(b);\n  } else if (typeof a === 'number') {\n    this.ex = Vec2.neo(a, c);\n    this.ey = Vec2.neo(b, d)\n  } else {\n    this.ex = Vec2.zero();\n    this.ey = Vec2.zero()\n  }\n};\n\nMat22.prototype.toString = function() {\n  return JSON.stringify(this);\n};\n\nMat22.isValid = function(o) {\n  return o && Vec2.isValid(o.ex) && Vec2.isValid(o.ey);\n};\n\nMat22.assert = function(o) {\n  if (!_ASSERT) return;\n  if (!Mat22.isValid(o)) {\n    _DEBUG && common.debug(o);\n    throw new Error('Invalid Mat22!');\n  }\n};\n\nMat22.prototype.set = function(a, b, c, d) {\n  if (typeof a === 'number' && typeof b === 'number' && typeof c === 'number'\n      && typeof d === 'number') {\n    this.ex.set(a, c);\n    this.ey.set(b, d);\n\n  } else if (typeof a === 'object' && typeof b === 'object') {\n    this.ex.set(a);\n    this.ey.set(b);\n\n  } else if (typeof a === 'object') {\n    _ASSERT && Mat22.assert(a);\n    this.ex.set(a.ex);\n    this.ey.set(a.ey);\n\n  } else {\n    _ASSERT && common.assert(false);\n  }\n}\n\nMat22.prototype.setIdentity = function() {\n  this.ex.x = 1.0;\n  this.ey.x = 0.0;\n  this.ex.y = 0.0;\n  this.ey.y = 1.0;\n}\n\nMat22.prototype.setZero = function() {\n  this.ex.x = 0.0;\n  this.ey.x = 0.0;\n  this.ex.y = 0.0;\n  this.ey.y = 0.0;\n}\n\nMat22.prototype.getInverse = function() {\n  var a = this.ex.x;\n  var b = this.ey.x;\n  var c = this.ex.y;\n  var d = this.ey.y;\n  var det = a * d - b * c;\n  if (det != 0.0) {\n    det = 1.0 / det;\n  }\n  var imx = new Mat22();\n  imx.ex.x = det * d;\n  imx.ey.x = -det * b;\n  imx.ex.y = -det * c;\n  imx.ey.y = det * a;\n  return imx;\n}\n\n/**\n * Solve A * x = b, where b is a column vector. This is more efficient than\n * computing the inverse in one-shot cases.\n */\nMat22.prototype.solve = function(v) {\n  _ASSERT && Vec2.assert(v);\n  var a = this.ex.x;\n  var b = this.ey.x;\n  var c = this.ex.y;\n  var d = this.ey.y;\n  var det = a * d - b * c;\n  if (det != 0.0) {\n    det = 1.0 / det;\n  }\n  var w = Vec2.zero();\n  w.x = det * (d * v.x - b * v.y);\n  w.y = det * (a * v.y - c * v.x);\n  return w;\n}\n\n/**\n * Multiply a matrix times a vector. If a rotation matrix is provided, then this\n * transforms the vector from one frame to another.\n */\nMat22.mul = function(mx, v) {\n  if (v && 'x' in v && 'y' in v) {\n    _ASSERT && Vec2.assert(v);\n    var x = mx.ex.x * v.x + mx.ey.x * v.y;\n    var y = mx.ex.y * v.x + mx.ey.y * v.y;\n    return Vec2.neo(x, y);\n\n  } else if (v && 'ex' in v && 'ey' in v) { // Mat22\n    _ASSERT && Mat22.assert(v);\n    // return new Mat22(Vec2.mul(mx, v.ex), Vec2.mul(mx, v.ey));\n    var a = mx.ex.x * v.ex.x + mx.ey.x * v.ex.y;\n    var b = mx.ex.x * v.ey.x + mx.ey.x * v.ey.y;\n    var c = mx.ex.y * v.ex.x + mx.ey.y * v.ex.y;\n    var d = mx.ex.y * v.ey.x + mx.ey.y * v.ey.y;\n    return new Mat22(a, b, c, d);\n  }\n\n  _ASSERT && common.assert(false);\n}\n\nMat22.mulVec2 = function(mx, v) {\n  _ASSERT && Vec2.assert(v);\n  var x = mx.ex.x * v.x + mx.ey.x * v.y;\n  var y = mx.ex.y * v.x + mx.ey.y * v.y;\n  return Vec2.neo(x, y);\n}\n\nMat22.mulMat22 = function(mx, v) {\n  _ASSERT && Mat22.assert(v);\n  // return new Mat22(Vec2.mul(mx, v.ex), Vec2.mul(mx, v.ey));\n  var a = mx.ex.x * v.ex.x + mx.ey.x * v.ex.y;\n  var b = mx.ex.x * v.ey.x + mx.ey.x * v.ey.y;\n  var c = mx.ex.y * v.ex.x + mx.ey.y * v.ex.y;\n  var d = mx.ex.y * v.ey.x + mx.ey.y * v.ey.y;\n  return new Mat22(a, b, c, d);\n  _ASSERT && common.assert(false);\n}\n\n/**\n * Multiply a matrix transpose times a vector. If a rotation matrix is provided,\n * then this transforms the vector from one frame to another (inverse\n * transform).\n */\nMat22.mulT = function(mx, v) {\n  if (v && 'x' in v && 'y' in v) { // Vec2\n    _ASSERT && Vec2.assert(v);\n    return Vec2.neo(Vec2.dot(v, mx.ex), Vec2.dot(v, mx.ey));\n\n  } else if (v && 'ex' in v && 'ey' in v) { // Mat22\n    _ASSERT && Mat22.assert(v);\n    var c1 = Vec2.neo(Vec2.dot(mx.ex, v.ex), Vec2.dot(mx.ey, v.ex));\n    var c2 = Vec2.neo(Vec2.dot(mx.ex, v.ey), Vec2.dot(mx.ey, v.ey));\n    return new Mat22(c1, c2);\n  }\n\n  _ASSERT && common.assert(false);\n}\n\nMat22.mulTVec2 = function(mx, v) {\n  _ASSERT && Mat22.assert(mx);\n  _ASSERT && Vec2.assert(v);\n  return Vec2.neo(Vec2.dot(v, mx.ex), Vec2.dot(v, mx.ey));\n}\n\nMat22.mulTMat22 = function(mx, v) {\n  _ASSERT && Mat22.assert(mx);\n  _ASSERT && Mat22.assert(v);\n  var c1 = Vec2.neo(Vec2.dot(mx.ex, v.ex), Vec2.dot(mx.ey, v.ex));\n  var c2 = Vec2.neo(Vec2.dot(mx.ex, v.ey), Vec2.dot(mx.ey, v.ey));\n  return new Mat22(c1, c2);\n}\n\nMat22.abs = function(mx) {\n  _ASSERT && Mat22.assert(mx);\n  return new Mat22(Vec2.abs(mx.ex), Vec2.abs(mx.ey));\n}\n\nMat22.add = function(mx1, mx2) {\n  _ASSERT && Mat22.assert(mx1);\n  _ASSERT && Mat22.assert(mx2);\n  return new Mat22(Vec2.add(mx1.ex, mx2.ex), Vec2.add(mx1.ey, mx2.ey));\n}\n","/*\n * Planck.js\n * The MIT License\n * Copyright (c) 2021 Erin Catto, Ali Shakiba\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 all\n * 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 THE\n * SOFTWARE.\n */\n\nvar _DEBUG = typeof DEBUG === 'undefined' ? false : DEBUG;\nvar _ASSERT = typeof ASSERT === 'undefined' ? false : ASSERT;\n\nmodule.exports = Mat33;\n\nvar common = require('../util/common');\nvar Math = require('./Math');\nvar Vec2 = require('./Vec2');\nvar Vec3 = require('./Vec3');\n\n/**\n * A 3-by-3 matrix. Stored in column-major order.\n */\nfunction Mat33(a, b, c) {\n  if (typeof a === 'object' && a !== null) {\n    this.ex = Vec3.clone(a);\n    this.ey = Vec3.clone(b);\n    this.ez = Vec3.clone(c);\n  } else {\n    this.ex = Vec3();\n    this.ey = Vec3();\n    this.ez = Vec3();\n  }\n};\n\nMat33.prototype.toString = function() {\n  return JSON.stringify(this);\n};\n\nMat33.isValid = function(o) {\n  return o && Vec3.isValid(o.ex) && Vec3.isValid(o.ey) && Vec3.isValid(o.ez);\n};\n\nMat33.assert = function(o) {\n  if (!_ASSERT) return;\n  if (!Mat33.isValid(o)) {\n    _DEBUG && common.debug(o);\n    throw new Error('Invalid Mat33!');\n  }\n};\n\n/**\n * Set this matrix to all zeros.\n */\nMat33.prototype.setZero = function() {\n  this.ex.setZero();\n  this.ey.setZero();\n  this.ez.setZero();\n  return this;\n}\n\n/**\n * Solve A * x = b, where b is a column vector. This is more efficient than\n * computing the inverse in one-shot cases.\n * \n * @param {Vec3} v\n * @returns {Vec3}\n */\nMat33.prototype.solve33 = function(v) {\n  var det = Vec3.dot(this.ex, Vec3.cross(this.ey, this.ez));\n  if (det != 0.0) {\n    det = 1.0 / det;\n  }\n  var r = new Vec3();\n  r.x = det * Vec3.dot(v, Vec3.cross(this.ey, this.ez));\n  r.y = det * Vec3.dot(this.ex, Vec3.cross(v, this.ez));\n  r.z = det * Vec3.dot(this.ex, Vec3.cross(this.ey, v));\n  return r;\n}\n\n/**\n * Solve A * x = b, where b is a column vector. This is more efficient than\n * computing the inverse in one-shot cases. Solve only the upper 2-by-2 matrix\n * equation.\n * \n * @param {Vec2} v\n * \n * @returns {Vec2}\n */\nMat33.prototype.solve22 = function(v) {\n  var a11 = this.ex.x;\n  var a12 = this.ey.x;\n  var a21 = this.ex.y;\n  var a22 = this.ey.y;\n  var det = a11 * a22 - a12 * a21;\n  if (det != 0.0) {\n    det = 1.0 / det;\n  }\n  var r = Vec2.zero();\n  r.x = det * (a22 * v.x - a12 * v.y);\n  r.y = det * (a11 * v.y - a21 * v.x);\n  return r;\n}\n\n/**\n * Get the inverse of this matrix as a 2-by-2. Returns the zero matrix if\n * singular.\n * \n * @param {Mat33} M\n */\nMat33.prototype.getInverse22 = function(M) {\n  var a = this.ex.x;\n  var b = this.ey.x;\n  var c = this.ex.y;\n  var d = this.ey.y;\n  var det = a * d - b * c;\n  if (det != 0.0) {\n    det = 1.0 / det;\n  }\n  M.ex.x = det * d;\n  M.ey.x = -det * b;\n  M.ex.z = 0.0;\n  M.ex.y = -det * c;\n  M.ey.y = det * a;\n  M.ey.z = 0.0;\n  M.ez.x = 0.0;\n  M.ez.y = 0.0;\n  M.ez.z = 0.0;\n}\n\n/**\n * Get the symmetric inverse of this matrix as a 3-by-3. Returns the zero matrix\n * if singular.\n * \n * @param {Mat33} M\n */\nMat33.prototype.getSymInverse33 = function(M) {\n  var det = Vec3.dot(this.ex, Vec3.cross(this.ey, this.ez));\n  if (det != 0.0) {\n    det = 1.0 / det;\n  }\n  var a11 = this.ex.x;\n  var a12 = this.ey.x;\n  var a13 = this.ez.x;\n  var a22 = this.ey.y;\n  var a23 = this.ez.y;\n  var a33 = this.ez.z;\n\n  M.ex.x = det * (a22 * a33 - a23 * a23);\n  M.ex.y = det * (a13 * a23 - a12 * a33);\n  M.ex.z = det * (a12 * a23 - a13 * a22);\n\n  M.ey.x = M.ex.y;\n  M.ey.y = det * (a11 * a33 - a13 * a13);\n  M.ey.z = det * (a13 * a12 - a11 * a23);\n\n  M.ez.x = M.ex.z;\n  M.ez.y = M.ey.z;\n  M.ez.z = det * (a11 * a22 - a12 * a12);\n}\n\n/**\n * Multiply a matrix times a vector.\n * \n * @param {Mat33} a\n * @param {Vec3|Vec2} b\n * \n * @returns {Vec3|Vec2}\n */\nMat33.mul = function(a, b) {\n  _ASSERT && Mat33.assert(a);\n  if (b && 'z' in b && 'y' in b && 'x' in b) {\n    _ASSERT && Vec3.assert(b);\n    var x = a.ex.x * b.x + a.ey.x * b.y + a.ez.x * b.z;\n    var y = a.ex.y * b.x + a.ey.y * b.y + a.ez.y * b.z;\n    var z = a.ex.z * b.x + a.ey.z * b.y + a.ez.z * b.z;\n    return new Vec3(x, y, z);\n\n  } else if (b && 'y' in b && 'x' in b) {\n    _ASSERT && Vec2.assert(b);\n    var x = a.ex.x * b.x + a.ey.x * b.y;\n    var y = a.ex.y * b.x + a.ey.y * b.y;\n    return Vec2.neo(x, y);\n  }\n\n  _ASSERT && common.assert(false);\n}\n\nMat33.mulVec3 = function(a, b) {\n  _ASSERT && Mat33.assert(a);\n  _ASSERT && Vec3.assert(b);\n  var x = a.ex.x * b.x + a.ey.x * b.y + a.ez.x * b.z;\n  var y = a.ex.y * b.x + a.ey.y * b.y + a.ez.y * b.z;\n  var z = a.ex.z * b.x + a.ey.z * b.y + a.ez.z * b.z;\n  return new Vec3(x, y, z);\n}\n\nMat33.mulVec2 = function(a, b) {\n  _ASSERT && Mat33.assert(a);\n  _ASSERT && Vec2.assert(b);\n  var x = a.ex.x * b.x + a.ey.x * b.y;\n  var y = a.ex.y * b.x + a.ey.y * b.y;\n  return Vec2.neo(x, y);\n}\n\nMat33.add = function(a, b) {\n  _ASSERT && Mat33.assert(a);\n  _ASSERT && Mat33.assert(b);\n  return new Mat33(\n    Vec3.add(a.ex, b.ex),\n    Vec3.add(a.ey, b.ey),\n    Vec3.add(a.ez, b.ez)\n  );\n}\n","/*\n * Planck.js\n * The MIT License\n * Copyright (c) 2021 Erin Catto, Ali Shakiba\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 all\n * 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 THE\n * SOFTWARE.\n */\n\nvar _DEBUG = typeof DEBUG === 'undefined' ? false : DEBUG;\nvar _ASSERT = typeof ASSERT === 'undefined' ? false : ASSERT;\n\nvar common = require('../util/common');\nvar native = Math;\nvar math = module.exports = Object.create(native);\n\nmath.EPSILON = 1e-9; // TODO\n\n/**\n * This function is used to ensure that a floating point number is not a NaN or\n * infinity.\n */\nmath.isFinite = function(x) {\n  return (typeof x === 'number') && isFinite(x) && !isNaN(x);\n}\n\nmath.assert = function(x) {\n  if (!_ASSERT) return;\n  if (!math.isFinite(x)) {\n    _DEBUG && common.debug(x);\n    throw new Error('Invalid Number!');\n  }\n}\n\n/**\n * TODO: This is a approximate yet fast inverse square-root.\n */\nmath.invSqrt = function(x) {\n  // TODO\n  return 1 / native.sqrt(x);\n}\n\n/**\n * Next Largest Power of 2 Given a binary integer value x, the next largest\n * power of 2 can be computed by a SWAR algorithm that recursively \"folds\" the\n * upper bits into the lower bits. This process yields a bit vector with the\n * same most significant 1 as x, but all 1's below it. Adding 1 to that value\n * yields the next largest power of 2. For a 32-bit value:\n */\nmath.nextPowerOfTwo = function(x) {\n  // TODO\n  x |= (x >> 1);\n  x |= (x >> 2);\n  x |= (x >> 4);\n  x |= (x >> 8);\n  x |= (x >> 16);\n  return x + 1;\n}\n\nmath.isPowerOfTwo = function(x) {\n  return x > 0 && (x & (x - 1)) == 0;\n}\n\nmath.mod = function(num, min, max) {\n  if (typeof min === 'undefined') {\n    max = 1, min = 0;\n  } else if (typeof max === 'undefined') {\n    max = min, min = 0;\n  }\n  if (max > min) {\n    num = (num - min) % (max - min);\n    return num + (num < 0 ? max : min);\n  } else {\n    num = (num - max) % (min - max);\n    return num + (num <= 0 ? min : max);\n  }\n};\n\nmath.clamp = function(num, min, max) {\n  if (num < min) {\n    return min;\n  } else if (num > max) {\n    return max;\n  } else {\n    return num;\n  }\n};\n\nmath.random = function(min, max) {\n  if (typeof min === 'undefined') {\n    max = 1;\n    min = 0;\n  } else if (typeof max === 'undefined') {\n    max = min;\n    min = 0;\n  }\n  return min == max ? min : native.random() * (max - min) + min;\n};\n","/*\n * Planck.js\n * The MIT License\n * Copyright (c) 2021 Erin Catto, Ali Shakiba\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 all\n * 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 THE\n * SOFTWARE.\n */\n\nvar _DEBUG = typeof DEBUG === 'undefined' ? false : DEBUG;\nvar _ASSERT = typeof ASSERT === 'undefined' ? false : ASSERT;\n\nmodule.exports = Position;\n\nvar Vec2 = require('./Vec2');\nvar Rot = require('./Rot');\n\n/**\n * @prop {Vec2} c location\n * @prop {float} a angle\n */\nfunction Position() {\n  this.c = Vec2.zero();\n  this.a = 0;\n}\n\nPosition.prototype.getTransform = function(xf, p) {\n  xf.q.set(this.a);\n  xf.p.set(Vec2.sub(this.c, Rot.mulVec2(xf.q, p)));\n  return xf;\n}\n","/*\n * Planck.js\n * The MIT License\n * Copyright (c) 2021 Erin Catto, Ali Shakiba\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 all\n * 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 THE\n * SOFTWARE.\n */\n\nvar _DEBUG = typeof DEBUG === 'undefined' ? false : DEBUG;\nvar _ASSERT = typeof ASSERT === 'undefined' ? false : ASSERT;\n\nmodule.exports = Rot;\n\nvar common = require('../util/common');\nvar Vec2 = require('./Vec2');\nvar Math = require('./Math');\n\n// TODO merge with Transform\n\n/**\n * Initialize from an angle in radians.\n */\nfunction Rot(angle) {\n  if (!(this instanceof Rot)) {\n    return new Rot(angle);\n  }\n  if (typeof angle === 'number') {\n    this.setAngle(angle);\n  } else if (typeof angle === 'object') {\n      this.set(angle);\n  } else {\n    this.setIdentity();\n  }\n}\n\nRot.neo = function(angle) {\n  var obj = Object.create(Rot.prototype);\n  obj.setAngle(angle);\n  return obj;\n};\n\nRot.clone = function(rot) {\n  _ASSERT && Rot.assert(rot);\n  var obj = Object.create(Rot.prototype);\n  obj.s = rot.s;\n  obj.c = rot.c;\n  return obj;\n};\n\nRot.identity = function() {\n  var obj = Object.create(Rot.prototype);\n  obj.s = 0.0;\n  obj.c = 1.0;\n  return obj;\n};\n\nRot.isValid = function(o) {\n  return o && Math.isFinite(o.s) && Math.isFinite(o.c);\n}\n\nRot.assert = function(o) {\n  if (!_ASSERT) return;\n  if (!Rot.isValid(o)) {\n    _DEBUG && common.debug(o);\n    throw new Error('Invalid Rot!');\n  }\n}\n\n/**\n * Set to the identity rotation.\n */\nRot.prototype.setIdentity = function() {\n  this.s = 0.0;\n  this.c = 1.0;\n}\n\nRot.prototype.set = function(angle) {\n  if (typeof angle === 'object') {\n    _ASSERT && Rot.assert(angle);\n    this.s = angle.s;\n    this.c = angle.c;\n\n  } else {\n    _ASSERT && Math.assert(angle);\n    // TODO_ERIN optimize\n    this.s = Math.sin(angle);\n    this.c = Math.cos(angle);\n  }\n}\n\n/**\n * Set using an angle in radians.\n */\nRot.prototype.setAngle = function(angle) {\n  _ASSERT && Math.assert(angle);\n  // TODO_ERIN optimize\n  this.s = Math.sin(angle);\n  this.c = Math.cos(angle);\n};\n\n/**\n * Get the angle in radians.\n */\nRot.prototype.getAngle = function() {\n  return Math.atan2(this.s, this.c);\n}\n\n/**\n * Get the x-axis.\n */\nRot.prototype.getXAxis = function() {\n  return Vec2.neo(this.c, this.s);\n}\n\n/**\n * Get the u-axis.\n */\nRot.prototype.getYAxis = function() {\n  return Vec2.neo(-this.s, this.c);\n}\n\n/**\n * Multiply two rotations: q * r\n * \n * @returns Rot\n * \n * Rotate a vector\n * \n * @returns Vec2\n */\nRot.mul = function(rot, m) {\n  _ASSERT && Rot.assert(rot);\n  if ('c' in m && 's' in m) {\n    _ASSERT && Rot.assert(m);\n    // [qc -qs] * [rc -rs] = [qc*rc-qs*rs -qc*rs-qs*rc]\n    // [qs qc] [rs rc] [qs*rc+qc*rs -qs*rs+qc*rc]\n    // s = qs * rc + qc * rs\n    // c = qc * rc - qs * rs\n    var qr = Rot.identity();\n    qr.s = rot.s * m.c + rot.c * m.s;\n    qr.c = rot.c * m.c - rot.s * m.s;\n    return qr;\n\n  } else if ('x' in m && 'y' in m) {\n    _ASSERT && Vec2.assert(m);\n    return Vec2.neo(rot.c * m.x - rot.s * m.y, rot.s * m.x + rot.c * m.y);\n  }\n}\n\nRot.mulRot = function(rot, m) {\n  _ASSERT && Rot.assert(rot);\n  _ASSERT && Rot.assert(m);\n  // [qc -qs] * [rc -rs] = [qc*rc-qs*rs -qc*rs-qs*rc]\n  // [qs qc] [rs rc] [qs*rc+qc*rs -qs*rs+qc*rc]\n  // s = qs * rc + qc * rs\n  // c = qc * rc - qs * rs\n  var qr = Rot.identity();\n  qr.s = rot.s * m.c + rot.c * m.s;\n  qr.c = rot.c * m.c - rot.s * m.s;\n  return qr;\n}\n\nRot.mulVec2 = function(rot, m) {\n  _ASSERT && Rot.assert(rot);\n  _ASSERT && Vec2.assert(m);\n  return Vec2.neo(rot.c * m.x - rot.s * m.y, rot.s * m.x + rot.c * m.y);\n}\n\nRot.mulSub = function(rot, v, w) {\n  var x = rot.c * (v.x - w.x) - rot.s * (v.y - w.y);\n  var y = rot.s * (v.x - w.x) + rot.c * (v.y - w.y);\n  return Vec2.neo(x, y);\n}\n\n/**\n * Transpose multiply two rotations: qT * r\n * \n * @returns Rot\n * \n * Inverse rotate a vector\n * \n * @returns Vec2\n */\nRot.mulT = function(rot, m) {\n  if ('c' in m && 's' in m) {\n    _ASSERT && Rot.assert(m);\n    // [ qc qs] * [rc -rs] = [qc*rc+qs*rs -qc*rs+qs*rc]\n    // [-qs qc] [rs rc] [-qs*rc+qc*rs qs*rs+qc*rc]\n    // s = qc * rs - qs * rc\n    // c = qc * rc + qs * rs\n    var qr = Rot.identity();\n    qr.s = rot.c * m.s - rot.s * m.c;\n    qr.c = rot.c * m.c + rot.s * m.s;\n    return qr;\n\n  } else if ('x' in m && 'y' in m) {\n    _ASSERT && Vec2.assert(m);\n    return Vec2.neo(rot.c * m.x + rot.s * m.y, -rot.s * m.x + rot.c * m.y);\n  }\n}\n\nRot.mulTRot = function(rot, m) {\n  _ASSERT && Rot.assert(m);\n  // [ qc qs] * [rc -rs] = [qc*rc+qs*rs -qc*rs+qs*rc]\n  // [-qs qc] [rs rc] [-qs*rc+qc*rs qs*rs+qc*rc]\n  // s = qc * rs - qs * rc\n  // c = qc * rc + qs * rs\n  var qr = Rot.identity();\n  qr.s = rot.c * m.s - rot.s * m.c;\n  qr.c = rot.c * m.c + rot.s * m.s;\n  return qr;\n}\n\nRot.mulTVec2 = function(rot, m) {\n  _ASSERT && Vec2.assert(m);\n  return Vec2.neo(rot.c * m.x + rot.s * m.y, -rot.s * m.x + rot.c * m.y);\n}\n","/*\n * Planck.js\n * The MIT License\n * Copyright (c) 2021 Erin Catto, Ali Shakiba\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 all\n * 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 THE\n * SOFTWARE.\n */\n\nvar _DEBUG = typeof DEBUG === 'undefined' ? false : DEBUG;\nvar _ASSERT = typeof ASSERT === 'undefined' ? false : ASSERT;\n\nmodule.exports = Sweep;\n\nvar common = require('../util/common');\nvar Math = require('./Math');\nvar Vec2 = require('./Vec2');\nvar Rot = require('./Rot');\nvar Transform = require('./Transform');\n\n/**\n * This describes the motion of a body/shape for TOI computation. Shapes are\n * defined with respect to the body origin, which may not coincide with the\n * center of mass. However, to support dynamics we must interpolate the center\n * of mass position.\n * \n * @prop {Vec2} localCenter Local center of mass position\n * @prop {Vec2} c World center position\n * @prop {float} a World angle\n * @prop {float} alpha0 Fraction of the current time step in the range [0,1], c0\n *       and a0 are c and a at alpha0.\n */\nfunction Sweep(c, a) {\n  _ASSERT && common.assert(typeof c === 'undefined');\n  _ASSERT && common.assert(typeof a === 'undefined');\n  this.localCenter = Vec2.zero();\n  this.c = Vec2.zero();\n  this.a = 0;\n  this.alpha0 = 0;\n  this.c0 = Vec2.zero();\n  this.a0 = 0;\n}\n\nSweep.prototype.setTransform = function(xf) {\n  var c = Transform.mulVec2(xf, this.localCenter);\n  this.c.set(c);\n  this.c0.set(c);\n\n  this.a = xf.q.getAngle();\n  this.a0 = xf.q.getAngle();\n};\n\nSweep.prototype.setLocalCenter = function(localCenter, xf) {\n  this.localCenter.set(localCenter);\n\n  var c = Transform.mulVec2(xf, this.localCenter);\n  this.c.set(c);\n  this.c0.set(c);\n};\n\n/**\n * Get the interpolated transform at a specific time.\n * \n * @param xf\n * @param beta A factor in [0,1], where 0 indicates alpha0\n */\nSweep.prototype.getTransform = function(xf, beta) {\n  beta = typeof beta === 'undefined' ? 0 : beta;\n  xf.q.setAngle((1.0 - beta) * this.a0 + beta * this.a);\n  xf.p.setCombine((1.0 - beta), this.c0, beta, this.c);\n\n  // shift to origin\n  xf.p.sub(Rot.mulVec2(xf.q, this.localCenter));\n};\n\n/**\n * Advance the sweep forward, yielding a new initial state.\n * \n * @param {float} alpha The new initial time\n */\nSweep.prototype.advance = function(alpha) {\n  _ASSERT && common.assert(this.alpha0 < 1.0);\n  var beta = (alpha - this.alpha0) / (1.0 - this.alpha0);\n  this.c0.setCombine(beta, this.c, 1 - beta, this.c0);\n  this.a0 = beta * this.a + (1 - beta) * this.a0;\n  this.alpha0 = alpha;\n};\n\nSweep.prototype.forward = function() {\n  this.a0 = this.a;\n  this.c0.set(this.c);\n};\n\n/**\n * normalize the angles in radians to be between -pi and pi.\n */\nSweep.prototype.normalize = function() {\n  var a0 = Math.mod(this.a0, -Math.PI, +Math.PI);\n  this.a -= this.a0 - a0;\n  this.a0 = a0;\n};\n\nSweep.prototype.clone = function() {\n  var clone = new Sweep();\n  clone.localCenter.set(this.localCenter);\n  clone.alpha0 = this.alpha0;\n  clone.a0 = this.a0;\n  clone.a = this.a;\n  clone.c0.set(this.c0);\n  clone.c.set(this.c);\n  return clone;\n};\n\nSweep.prototype.set = function(that) {\n  this.localCenter.set(that.localCenter);\n  this.alpha0 = that.alpha0;\n  this.a0 = that.a0;\n  this.a = that.a;\n  this.c0.set(that.c0);\n  this.c.set(that.c);\n};\n","/*\n * Planck.js\n * The MIT License\n * Copyright (c) 2021 Erin Catto, Ali Shakiba\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 all\n * 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 THE\n * SOFTWARE.\n */\n\nvar _DEBUG = typeof DEBUG === 'undefined' ? false : DEBUG;\nvar _ASSERT = typeof ASSERT === 'undefined' ? false : ASSERT;\n\nmodule.exports = Transform;\n\nvar common = require('../util/common');\nvar Vec2 = require('./Vec2');\nvar Rot = require('./Rot');\n\n// TODO merge with Rot\n\n/**\n * A transform contains translation and rotation. It is used to represent the\n * position and orientation of rigid frames. Initialize using a position vector\n * and a rotation.\n *\n * @prop {Vec2} position\n * @prop {Rot} rotation\n */\nfunction Transform(position, rotation) {\n  if (!(this instanceof Transform)) {\n    return new Transform(position, rotation);\n  }\n  this.p = Vec2.zero();\n  this.q = Rot.identity();\n  if (typeof position !== 'undefined') {\n    this.p.set(position);\n  }\n  if (typeof rotation !== 'undefined') {\n    this.q.set(rotation);\n  }\n};\n\nTransform.clone = function(xf) {\n  var obj = Object.create(Transform.prototype);\n  obj.p = Vec2.clone(xf.p);\n  obj.q = Rot.clone(xf.q);\n  return obj;\n};\n\nTransform.neo = function(position, rotation) {\n  var obj = Object.create(Transform.prototype);\n  obj.p = Vec2.clone(position);\n  obj.q = Rot.clone(rotation);\n  return obj;\n};\n\nTransform.identity = function() {\n  var obj = Object.create(Transform.prototype);\n  obj.p = Vec2.zero();\n  obj.q = Rot.identity();\n  return obj;\n};\n\n/**\n * Set this to the identity transform.\n */\nTransform.prototype.setIdentity = function() {\n  this.p.setZero();\n  this.q.setIdentity();\n}\n\n/**\n * Set this based on the position and angle.\n */\nTransform.prototype.set = function(a, b) {\n  if (typeof b === 'undefined') {\n    this.p.set(a.p);\n    this.q.set(a.q);\n  } else {\n    this.p.set(a);\n    this.q.set(b);\n  }\n}\n\nTransform.isValid = function(o) {\n  return o && Vec2.isValid(o.p) && Rot.isValid(o.q);\n}\n\nTransform.assert = function(o) {\n  if (!_ASSERT) return;\n  if (!Transform.isValid(o)) {\n    _DEBUG && common.debug(o);\n    throw new Error('Invalid Transform!');\n  }\n}\n\n/**\n * @param {Transform} a\n * @param {Vec2} b\n * @returns {Vec2}\n *\n * @param {Transform} a\n * @param {Transform} b\n * @returns {Transform}\n */\nTransform.mul = function(a, b) {\n  _ASSERT && Transform.assert(a);\n  if (Array.isArray(b)) {\n    var arr = [];\n    for (var i = 0; i < b.length; i++) {\n      arr[i] = Transform.mul(a, b[i]);\n    }\n    return arr;\n\n  } else if ('x' in b && 'y' in b) {\n    _ASSERT && Vec2.assert(b);\n    var x = (a.q.c * b.x - a.q.s * b.y) + a.p.x;\n    var y = (a.q.s * b.x + a.q.c * b.y) + a.p.y;\n    return Vec2.neo(x, y);\n\n  } else if ('p' in b && 'q' in b) {\n    _ASSERT && Transform.assert(b);\n    // v2 = A.q.Rot(B.q.Rot(v1) + B.p) + A.p\n    // = (A.q * B.q).Rot(v1) + A.q.Rot(B.p) + A.p\n    var xf = Transform.identity();\n    xf.q = Rot.mulRot(a.q, b.q);\n    xf.p = Vec2.add(Rot.mulVec2(a.q, b.p), a.p);\n    return xf;\n  }\n}\n\n/**\n * @deprecated Use mulFn instead.\n */\nTransform.mulAll = function(a, b) {\n  _ASSERT && Transform.assert(a);\n  var arr = [];\n  for (var i = 0; i < b.length; i++) {\n    arr[i] = Transform.mul(a, b[i]);\n  }\n  return arr;\n}\n\n/**\n * @experimental\n */\nTransform.mulFn = function(a) {\n  _ASSERT && Transform.assert(a);\n  return function(b) {\n    return Transform.mul(a, b);\n  };\n}\n\nTransform.mulVec2 = function(a, b) {\n  _ASSERT && Transform.assert(a);\n  _ASSERT && Vec2.assert(b);\n  var x = (a.q.c * b.x - a.q.s * b.y) + a.p.x;\n  var y = (a.q.s * b.x + a.q.c * b.y) + a.p.y;\n  return Vec2.neo(x, y);\n}\n\nTransform.mulXf = function(a, b) {\n  _ASSERT && Transform.assert(a);\n  _ASSERT && Transform.assert(b);\n  // v2 = A.q.Rot(B.q.Rot(v1) + B.p) + A.p\n  // = (A.q * B.q).Rot(v1) + A.q.Rot(B.p) + A.p\n  var xf = Transform.identity();\n  xf.q = Rot.mulRot(a.q, b.q);\n  xf.p = Vec2.add(Rot.mulVec2(a.q, b.p), a.p);\n  return xf;\n}\n\n/**\n * @param {Transform} a\n * @param {Vec2} b\n * @returns {Vec2}\n *\n * @param {Transform} a\n * @param {Transform} b\n * @returns {Transform}\n */\nTransform.mulT = function(a, b) {\n  _ASSERT && Transform.assert(a);\n  if ('x' in b && 'y' in b) {\n    _ASSERT && Vec2.assert(b)\n    var px = b.x - a.p.x;\n    var py = b.y - a.p.y;\n    var x = (a.q.c * px + a.q.s * py);\n    var y = (-a.q.s * px + a.q.c * py);\n    return Vec2.neo(x, y);\n\n  } else if ('p' in b && 'q' in b) {\n    _ASSERT && Transform.assert(b);\n    // v2 = A.q' * (B.q * v1 + B.p - A.p)\n    // = A.q' * B.q * v1 + A.q' * (B.p - A.p)\n    var xf = Transform.identity();\n    xf.q.set(Rot.mulTRot(a.q, b.q));\n    xf.p.set(Rot.mulTVec2(a.q, Vec2.sub(b.p, a.p)));\n    return xf;\n  }\n}\n\nTransform.mulTVec2 = function(a, b) {\n  _ASSERT && Transform.assert(a);\n  _ASSERT && Vec2.assert(b)\n  var px = b.x - a.p.x;\n  var py = b.y - a.p.y;\n  var x = (a.q.c * px + a.q.s * py);\n  var y = (-a.q.s * px + a.q.c * py);\n  return Vec2.neo(x, y);\n}\n\nTransform.mulTXf = function(a, b) {\n  _ASSERT && Transform.assert(a);\n  _ASSERT && Transform.assert(b);\n  // v2 = A.q' * (B.q * v1 + B.p - A.p)\n  // = A.q' * B.q * v1 + A.q' * (B.p - A.p)\n  var xf = Transform.identity();\n  xf.q.set(Rot.mulTRot(a.q, b.q));\n  xf.p.set(Rot.mulTVec2(a.q, Vec2.sub(b.p, a.p)));\n  return xf;\n}\n","/*\n * Planck.js\n * The MIT License\n * Copyright (c) 2021 Erin Catto, Ali Shakiba\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 all\n * 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 THE\n * SOFTWARE.\n */\n\nvar _DEBUG = typeof DEBUG === 'undefined' ? false : DEBUG;\nvar _ASSERT = typeof ASSERT === 'undefined' ? false : ASSERT;\n\nmodule.exports = Vec2;\n\nvar common = require('../util/common');\nvar Math = require('./Math');\n\nfunction Vec2(x, y) {\n  if (!(this instanceof Vec2)) {\n    return new Vec2(x, y);\n  }\n  if (typeof x === 'undefined') {\n    this.x = 0;\n    this.y = 0;\n  } else if (typeof x === 'object') {\n    this.x = x.x;\n    this.y = x.y;\n  } else {\n    this.x = x;\n    this.y = y;\n  }\n  _ASSERT && Vec2.assert(this);\n}\n\nVec2.prototype._serialize = function() {\n  return {\n    x: this.x,\n    y: this.y\n  };\n};\n\nVec2._deserialize = function(data) {\n  var obj = Object.create(Vec2.prototype);\n  obj.x = data.x;\n  obj.y = data.y;\n  return obj;\n};\n\nVec2.zero = function() {\n  var obj = Object.create(Vec2.prototype);\n  obj.x = 0;\n  obj.y = 0;\n  return obj;\n};\n\nVec2.neo = function(x, y) {\n  var obj = Object.create(Vec2.prototype);\n  obj.x = x;\n  obj.y = y;\n  return obj;\n};\n\nVec2.clone = function(v) {\n  _ASSERT && Vec2.assert(v);\n  return Vec2.neo(v.x, v.y);\n};\n\nVec2.prototype.toString = function() {\n  return JSON.stringify(this);\n};\n\n/**\n * Does this vector contain finite coordinates?\n */\nVec2.isValid = function(v) {\n  return v && Math.isFinite(v.x) && Math.isFinite(v.y);\n}\n\nVec2.assert = function(o) {\n  if (!_ASSERT) return;\n  if (!Vec2.isValid(o)) {\n    _DEBUG && common.debug(o);\n    throw new Error('Invalid Vec2!');\n  }\n}\n\nVec2.prototype.clone = function() {\n  return Vec2.clone(this);\n}\n\n/**\n * Set this vector to all zeros.\n * \n * @returns this\n */\nVec2.prototype.setZero = function() {\n  this.x = 0.0;\n  this.y = 0.0;\n  return this;\n}\n\n/**\n * Set this vector to some specified coordinates.\n * \n * @returns this\n */\nVec2.prototype.set = function(x, y) {\n  if (typeof x === 'object') {\n    _ASSERT && Vec2.assert(x);\n    this.x = x.x;\n    this.y = x.y;\n  } else {\n    _ASSERT && Math.assert(x);\n    _ASSERT && Math.assert(y);\n    this.x = x;\n    this.y = y;\n  }\n  return this;\n}\n\n/**\n * @deprecated Use setCombine or setMul\n */\nVec2.prototype.wSet = function(a, v, b, w) {\n  if (typeof b !== 'undefined' || typeof w !== 'undefined') {\n    return this.setCombine(a, v, b, w);\n  } else {\n    return this.setMul(a, v);\n  }\n}\n\n/**\n * Set linear combination of v and w: `a * v + b * w`\n */\nVec2.prototype.setCombine = function(a, v, b, w) {\n  _ASSERT && Math.assert(a);\n  _ASSERT && Vec2.assert(v);\n  _ASSERT && Math.assert(b);\n  _ASSERT && Vec2.assert(w);\n  var x = a * v.x + b * w.x;\n  var y = a * v.y + b * w.y;\n\n  // `this` may be `w`\n  this.x = x;\n  this.y = y;\n  return this;\n}\n\nVec2.prototype.setMul = function(a, v) {\n  _ASSERT && Math.assert(a);\n  _ASSERT && Vec2.assert(v);\n  var x = a * v.x;\n  var y = a * v.y;\n\n  this.x = x;\n  this.y = y;\n  return this;\n}\n\n/**\n * Add a vector to this vector.\n * \n * @returns this\n */\nVec2.prototype.add = function(w) {\n  _ASSERT && Vec2.assert(w);\n  this.x += w.x;\n  this.y += w.y;\n  return this;\n}\n\n/**\n * @deprecated Use addCombine or addMul\n */\nVec2.prototype.wAdd = function(a, v, b, w) {\n  if (typeof b !== 'undefined' || typeof w !== 'undefined') {\n    return this.addCombine(a, v, b, w);\n  } else {\n    return this.addMul(a, v);\n  }\n}\n\n/**\n * Add linear combination of v and w: `a * v + b * w`\n */\nVec2.prototype.addCombine = function(a, v, b, w) {\n  _ASSERT && Math.assert(a);\n  _ASSERT && Vec2.assert(v);\n  _ASSERT && Math.assert(b);\n  _ASSERT && Vec2.assert(w);\n\n  var x = a * v.x + b * w.x;\n  var y = a * v.y + b * w.y;\n\n  // `this` may be `w`\n  this.x += x;\n  this.y += y;\n  return this;\n}\n\nVec2.prototype.addMul = function(a, v) {\n  _ASSERT && Math.assert(a);\n  _ASSERT && Vec2.assert(v);\n  var x = a * v.x;\n  var y = a * v.y;\n\n  this.x += x;\n  this.y += y;\n  return this;\n}\n\n/**\n * @deprecated Use subCombine or subMul\n */\nVec2.prototype.wSub = function(a, v, b, w) {\n  if (typeof b !== 'undefined' || typeof w !== 'undefined') {\n    return this.subCombine(a, v, b, w);\n  } else {\n    return this.subMul(a, v);\n  }}\n\n/**\n * Subtract linear combination of v and w: `a * v + b * w`\n */\nVec2.prototype.subCombine = function(a, v, b, w) {\n  _ASSERT && Math.assert(a);\n  _ASSERT && Vec2.assert(v);\n  _ASSERT && Math.assert(b);\n  _ASSERT && Vec2.assert(w);\n  var x = a * v.x + b * w.x;\n  var y = a * v.y + b * w.y;\n\n  // `this` may be `w`\n  this.x -= x;\n  this.y -= y;\n  return this;\n}\n\nVec2.prototype.subMul = function(a, v) {\n  _ASSERT && Math.assert(a);\n  _ASSERT && Vec2.assert(v);\n  var x = a * v.x;\n  var y = a * v.y;\n\n  this.x -= x;\n  this.y -= y;\n  return this;\n}\n\n/**\n * Subtract a vector from this vector\n * \n * @returns this\n */\nVec2.prototype.sub = function(w) {\n  _ASSERT && Vec2.assert(w);\n  this.x -= w.x;\n  this.y -= w.y;\n  return this;\n}\n\n/**\n * Multiply this vector by a scalar.\n * \n * @returns this\n */\nVec2.prototype.mul = function(m) {\n  _ASSERT && Math.assert(m);\n  this.x *= m;\n  this.y *= m;\n  return this;\n}\n\n/**\n * Get the length of this vector (the norm).\n * \n * For performance, use this instead of lengthSquared (if possible).\n */\nVec2.prototype.length = function() {\n  return Vec2.lengthOf(this);\n}\n\n/**\n * Get the length squared.\n */\nVec2.prototype.lengthSquared = function() {\n  return Vec2.lengthSquared(this);\n}\n\n/**\n * Convert this vector into a unit vector.\n * \n * @returns old length\n */\nVec2.prototype.normalize = function() {\n  var length = this.length();\n  if (length < Math.EPSILON) {\n    return 0.0;\n  }\n  var invLength = 1.0 / length;\n  this.x *= invLength;\n  this.y *= invLength;\n  return length;\n}\n\n/**\n * Get the length of this vector (the norm).\n *\n * For performance, use this instead of lengthSquared (if possible).\n */\nVec2.lengthOf = function(v) {\n  _ASSERT && Vec2.assert(v);\n  return Math.sqrt(v.x * v.x + v.y * v.y);\n}\n\n/**\n * Get the length squared.\n */\nVec2.lengthSquared = function(v) {\n  _ASSERT && Vec2.assert(v);\n  return v.x * v.x + v.y * v.y;\n}\n\nVec2.distance = function(v, w) {\n  _ASSERT && Vec2.assert(v);\n  _ASSERT && Vec2.assert(w);\n  var dx = v.x - w.x, dy = v.y - w.y;\n  return Math.sqrt(dx * dx + dy * dy);\n}\n\nVec2.distanceSquared = function(v, w) {\n  _ASSERT && Vec2.assert(v);\n  _ASSERT && Vec2.assert(w);\n  var dx = v.x - w.x, dy = v.y - w.y;\n  return dx * dx + dy * dy;\n}\n\nVec2.areEqual = function(v, w) {\n  _ASSERT && Vec2.assert(v);\n  _ASSERT && Vec2.assert(w);\n  return v == w || typeof w === 'object' && w !== null && v.x === w.x && v.y === w.y;\n}\n\n/**\n * Get the skew vector such that dot(skew_vec, other) == cross(vec, other)\n */\nVec2.skew = function(v) {\n  _ASSERT && Vec2.assert(v);\n  return Vec2.neo(-v.y, v.x);\n}\n\n/**\n * Perform the dot product on two vectors.\n */\nVec2.dot = function(v, w) {\n  _ASSERT && Vec2.assert(v);\n  _ASSERT && Vec2.assert(w);\n  return v.x * w.x + v.y * w.y;\n}\n\n/**\n * Perform the cross product on two vectors. In 2D this produces a scalar.\n * \n * Perform the cross product on a vector and a scalar. In 2D this produces a\n * vector.\n */\nVec2.cross = function(v, w) {\n  if (typeof w === 'number') {\n    _ASSERT && Vec2.assert(v);\n    _ASSERT && Math.assert(w);\n    return Vec2.neo(w * v.y, -w * v.x);\n\n  } else if (typeof v === 'number') {\n    _ASSERT && Math.assert(v);\n    _ASSERT && Vec2.assert(w);\n    return Vec2.neo(-v * w.y, v * w.x);\n\n  } else {\n    _ASSERT && Vec2.assert(v);\n    _ASSERT && Vec2.assert(w);\n    return v.x * w.y - v.y * w.x\n  }\n}\n\n/**\n * Returns `a + (v x w)`\n */\nVec2.addCross = function(a, v, w) {\n  if (typeof w === 'number') {\n    _ASSERT && Vec2.assert(v);\n    _ASSERT && Math.assert(w);\n    return Vec2.neo(w * v.y + a.x, -w * v.x + a.y);\n\n  } else if (typeof v === 'number') {\n    _ASSERT && Math.assert(v);\n    _ASSERT && Vec2.assert(w);\n    return Vec2.neo(-v * w.y + a.x, v * w.x + a.y);\n  }\n\n  _ASSERT && common.assert(false);\n}\n\nVec2.add = function(v, w) {\n  _ASSERT && Vec2.assert(v);\n  _ASSERT && Vec2.assert(w);\n  return Vec2.neo(v.x + w.x, v.y + w.y);\n}\n\n/**\n * @deprecated Use combine\n */\nVec2.wAdd = function(a, v, b, w) {\n  if (typeof b !== 'undefined' || typeof w !== 'undefined') {\n    return Vec2.combine(a, v, b, w);\n  } else {\n    return Vec2.mul(a, v);\n  }\n}\n\nVec2.combine = function(a, v, b, w) {\n  return Vec2.zero().setCombine(a, v, b, w);\n}\n\nVec2.sub = function(v, w) {\n  _ASSERT && Vec2.assert(v);\n  _ASSERT && Vec2.assert(w);\n  return Vec2.neo(v.x - w.x, v.y - w.y);\n}\n\nVec2.mul = function(a, b) {\n  if (typeof a === 'object') {\n    _ASSERT && Vec2.assert(a);\n    _ASSERT && Math.assert(b);\n    return Vec2.neo(a.x * b, a.y * b);\n\n  } else if (typeof b === 'object') {\n    _ASSERT && Math.assert(a);\n    _ASSERT && Vec2.assert(b);\n    return Vec2.neo(a * b.x, a * b.y);\n  }\n}\n\nVec2.prototype.neg = function() {\n  this.x = -this.x;\n  this.y = -this.y;\n  return this;\n}\n\nVec2.neg = function(v) {\n  _ASSERT && Vec2.assert(v);\n  return Vec2.neo(-v.x, -v.y);\n}\n\nVec2.abs = function(v) {\n  _ASSERT && Vec2.assert(v);\n  return Vec2.neo(Math.abs(v.x), Math.abs(v.y));\n}\n\nVec2.mid = function(v, w) {\n  _ASSERT && Vec2.assert(v);\n  _ASSERT && Vec2.assert(w);\n  return Vec2.neo((v.x + w.x) * 0.5, (v.y + w.y) * 0.5);\n}\n\nVec2.upper = function(v, w) {\n  _ASSERT && Vec2.assert(v);\n  _ASSERT && Vec2.assert(w);\n  return Vec2.neo(Math.max(v.x, w.x), Math.max(v.y, w.y));\n}\n\nVec2.lower = function(v, w) {\n  _ASSERT && Vec2.assert(v);\n  _ASSERT && Vec2.assert(w);\n  return Vec2.neo(Math.min(v.x, w.x), Math.min(v.y, w.y));\n}\n\nVec2.prototype.clamp = function(max) {\n  var lengthSqr = this.x * this.x + this.y * this.y;\n  if (lengthSqr > max * max) {\n    var invLength = Math.invSqrt(lengthSqr);\n    this.x *= invLength * max;\n    this.y *= invLength * max;\n  }\n  return this;\n}\n\nVec2.clamp = function(v, max) {\n  v = Vec2.neo(v.x, v.y);\n  v.clamp(max);\n  return v;\n}\n\n/**\n * @experimental\n */\nVec2.scaleFn = function (x, y) {\n  return function (v) {\n    return Vec2.neo(v.x * x, v.y * y);\n  };\n}\n\n/**\n * @experimental\n */\nVec2.translateFn = function(x, y) {\n  return function (v) {\n    return Vec2.neo(v.x + x, v.y + y);\n  };\n}\n","/*\n * Planck.js\n * The MIT License\n * Copyright (c) 2021 Erin Catto, Ali Shakiba\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 all\n * 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 THE\n * SOFTWARE.\n */\n\nvar _DEBUG = typeof DEBUG === 'undefined' ? false : DEBUG;\nvar _ASSERT = typeof ASSERT === 'undefined' ? false : ASSERT;\n\nmodule.exports = Vec3;\n\nvar common = require('../util/common');\nvar Math = require('./Math');\n\nfunction Vec3(x, y, z) {\n  if (!(this instanceof Vec3)) {\n    return new Vec3(x, y, z);\n  }\n  if (typeof x === 'undefined') {\n    this.x = 0, this.y = 0, this.z = 0;\n  } else if (typeof x === 'object') {\n    this.x = x.x, this.y = x.y, this.z = x.z;\n  } else {\n    this.x = x, this.y = y, this.z = z;\n  }\n  _ASSERT && Vec3.assert(this);\n};\n\nVec3.prototype._serialize = function() {\n  return {\n    x: this.x,\n    y: this.y,\n    z: this.z\n  };\n};\n\nVec3._deserialize = function(data) {\n  var obj = Object.create(Vec3.prototype);\n  obj.x = data.x;\n  obj.y = data.y;\n  obj.z = data.z;\n  return obj;\n};\n\nVec3.neo = function(x, y, z) {\n  var obj = Object.create(Vec3.prototype);\n  obj.x = x;\n  obj.y = y;\n  obj.z = z;\n  return obj;\n};\n\nVec3.clone = function(v) {\n  _ASSERT && Vec3.assert(v);\n  return Vec3.neo(v.x, v.y, v.z);\n};\n\nVec3.prototype.toString = function() {\n  return JSON.stringify(this);\n};\n\n/**\n * Does this vector contain finite coordinates?\n */\nVec3.isValid = function(v) {\n  return v && Math.isFinite(v.x) && Math.isFinite(v.y) && Math.isFinite(v.z);\n}\n\nVec3.assert = function(o) {\n  if (!_ASSERT) return;\n  if (!Vec3.isValid(o)) {\n    _DEBUG && common.debug(o);\n    throw new Error('Invalid Vec3!');\n  }\n}\n\nVec3.prototype.setZero = function() {\n  this.x = 0.0;\n  this.y = 0.0;\n  this.z = 0.0;\n  return this;\n}\n\nVec3.prototype.set = function(x, y, z) {\n  this.x = x;\n  this.y = y;\n  this.z = z;\n  return this;\n}\n\nVec3.prototype.add = function(w) {\n  this.x += w.x;\n  this.y += w.y;\n  this.z += w.z;\n  return this;\n}\n\nVec3.prototype.sub = function(w) {\n  this.x -= w.x;\n  this.y -= w.y;\n  this.z -= w.z;\n  return this;\n}\n\nVec3.prototype.mul = function(m) {\n  this.x *= m;\n  this.y *= m;\n  this.z *= m;\n  return this;\n}\n\nVec3.areEqual = function(v, w) {\n  _ASSERT && Vec3.assert(v);\n  _ASSERT && Vec3.assert(w);\n  return v == w ||\n    typeof v === 'object' && v !== null &&\n    typeof w === 'object' && w !== null &&\n    v.x === w.x && v.y === w.y && v.z === w.z;\n}\n\n/**\n * Perform the dot product on two vectors.\n */\nVec3.dot = function(v, w) {\n  return v.x * w.x + v.y * w.y + v.z * w.z;\n}\n\n/**\n * Perform the cross product on two vectors. In 2D this produces a scalar.\n */\nVec3.cross = function(v, w) {\n  return new Vec3(\n    v.y * w.z - v.z * w.y,\n    v.z * w.x - v.x * w.z,\n    v.x * w.y - v.y * w.x\n  );\n}\n\nVec3.add = function(v, w) {\n  return new Vec3(v.x + w.x, v.y + w.y, v.z + w.z);\n}\n\nVec3.sub = function(v, w) {\n  return new Vec3(v.x - w.x, v.y - w.y, v.z - w.z);\n}\n\nVec3.mul = function(v, m) {\n  return new Vec3(m * v.x, m * v.y, m * v.z);\n}\n\nVec3.prototype.neg = function() {\n  this.x = -this.x;\n  this.y = -this.y;\n  this.z = -this.z;\n  return this;\n}\n\nVec3.neg = function(v) {\n  return new Vec3(-v.x, -v.y, -v.z);\n}\n","/*\n * Planck.js\n * The MIT License\n * Copyright (c) 2021 Erin Catto, Ali Shakiba\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 all\n * 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 THE\n * SOFTWARE.\n */\n\nvar _DEBUG = typeof DEBUG === 'undefined' ? false : DEBUG;\nvar _ASSERT = typeof ASSERT === 'undefined' ? false : ASSERT;\n\nmodule.exports = Velocity;\n\nvar Vec2 = require('./Vec2');\n\n/**\n * @prop {Vec2} v linear\n * @prop {float} w angular\n */\nfunction Velocity() {\n  this.v = Vec2.zero();\n  this.w = 0;\n}\n","var _DEBUG = typeof DEBUG === 'undefined' ? false : DEBUG;\nvar _ASSERT = typeof ASSERT === 'undefined' ? false : ASSERT;\n\nexports.toString = function(newline) {\n  newline = typeof newline === 'string' ? newline : '\\n';\n  var string = \"\";\n  for (var name in this) {\n    if (typeof this[name] !== 'function' && typeof this[name] !== 'object') {\n      string += name + ': ' + this[name] + newline;\n    }\n  }\n  return string;\n};","exports.internal = {};\n\nexports.Serializer = require('./serializer');\n\nexports.Math = require('./common/Math');\nexports.Vec2 = require('./common/Vec2');\nexports.Vec3 = require('./common/Vec3');\nexports.Mat22 = require('./common/Mat22');\nexports.Mat33 = require('./common/Mat33');\nexports.Transform = require('./common/Transform');\nexports.Rot = require('./common/Rot');\n\nexports.AABB = require('./collision/AABB');\n\nexports.Shape = require('./Shape');\nexports.Fixture = require('./Fixture');\nexports.Body = require('./Body');\nexports.Contact = require('./Contact');\nexports.Joint = require('./Joint');\nexports.World = require('./World');\n\nexports.Circle = require('./shape/CircleShape');\nexports.Edge = require('./shape/EdgeShape');\nexports.Polygon = require('./shape/PolygonShape');\nexports.Chain = require('./shape/ChainShape');\nexports.Box = require('./shape/BoxShape');\n\nrequire('./shape/CollideCircle');\nrequire('./shape/CollideEdgeCircle');\nexports.internal.CollidePolygons = require('./shape/CollidePolygon');\nrequire('./shape/CollideCirclePolygone');\nrequire('./shape/CollideEdgePolygon');\n\nexports.DistanceJoint = require('./joint/DistanceJoint');\nexports.FrictionJoint = require('./joint/FrictionJoint');\nexports.GearJoint = require('./joint/GearJoint');\nexports.MotorJoint = require('./joint/MotorJoint');\nexports.MouseJoint = require('./joint/MouseJoint');\nexports.PrismaticJoint = require('./joint/PrismaticJoint');\nexports.PulleyJoint = require('./joint/PulleyJoint');\nexports.RevoluteJoint = require('./joint/RevoluteJoint');\nexports.RopeJoint = require('./joint/RopeJoint');\nexports.WeldJoint = require('./joint/WeldJoint');\nexports.WheelJoint = require('./joint/WheelJoint');\n\nexports.Settings = require('./Settings');\n\nexports.internal.Sweep = require('./common/Sweep');\nexports.internal.stats = require('./common/stats'); // todo: remove this\nexports.internal.Manifold = require('./Manifold');\nexports.internal.Distance = require('./collision/Distance');\nexports.internal.TimeOfImpact = require('./collision/TimeOfImpact');\nexports.internal.DynamicTree = require('./collision/DynamicTree');\nexports.internal.Settings = exports.Settings;\n","/*\n * Planck.js\n * The MIT License\n * Copyright (c) 2021 Erin Catto, Ali Shakiba\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 all\n * 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 THE\n * SOFTWARE.\n */\n\nvar _DEBUG = typeof DEBUG === 'undefined' ? false : DEBUG;\nvar _ASSERT = typeof ASSERT === 'undefined' ? false : ASSERT;\n\nmodule.exports = DistanceJoint;\n\nvar options = require('../util/options');\nvar Settings = require('../Settings');\n\nvar Math = require('../common/Math');\nvar Vec2 = require('../common/Vec2');\nvar Vec3 = require('../common/Vec3');\nvar Mat22 = require('../common/Mat22');\nvar Mat33 = require('../common/Mat33');\nvar Rot = require('../common/Rot');\nvar Sweep = require('../common/Sweep');\nvar Transform = require('../common/Transform');\nvar Velocity = require('../common/Velocity');\nvar Position = require('../common/Position');\n\nvar Joint = require('../Joint');\nvar Body = require('../Body');\n\nDistanceJoint.TYPE = 'distance-joint';\nJoint.TYPES[DistanceJoint.TYPE] = DistanceJoint;\n\nDistanceJoint._super = Joint;\nDistanceJoint.prototype = Object.create(DistanceJoint._super.prototype);\n\n/**\n * @typedef {Object} DistanceJointDef\n *\n * Distance joint definition. This requires defining an anchor point on both\n * bodies and the non-zero length of the distance joint. The definition uses\n * local anchor points so that the initial configuration can violate the\n * constraint slightly. This helps when saving and loading a game. Warning: Do\n * not use a zero or short length.\n * \n * @prop {float} frequencyHz The mass-spring-damper frequency in Hertz. A value\n *       of 0 disables softness.\n * @prop {float} dampingRatio The damping ratio. 0 = no damping, 1 = critical\n *       damping.\n *\n * @prop {Vec2} localAnchorA The local anchor point relative to bodyA's origin.\n * @prop {Vec2} localAnchorB The local anchor point relative to bodyB's origin.\n * @prop {number} length Distance length.\n */\n\nvar DEFAULTS = {\n  frequencyHz : 0.0,\n  dampingRatio : 0.0\n};\n\n/**\n * A distance joint constrains two points on two bodies to remain at a fixed\n * distance from each other. You can view this as a massless, rigid rod.\n *\n * @param {DistanceJointDef} def\n * @param {Body} bodyA\n * @param {Body} bodyB\n * @param {Vec2} anchorA Anchor A in global coordination.\n * @param {Vec2} anchorB Anchor B in global coordination.\n */\nfunction DistanceJoint(def, bodyA, bodyB, anchorA, anchorB) {\n  if (!(this instanceof DistanceJoint)) {\n    return new DistanceJoint(def, bodyA, bodyB, anchorA, anchorB);\n  }\n\n  // order of constructor arguments is changed in v0.2\n  if (bodyB && anchorA && ('m_type' in anchorA) && ('x' in bodyB) && ('y' in bodyB)) {\n    var temp = bodyB;\n    bodyB = anchorA;\n    anchorA = temp;\n  }\n\n  def = options(def, DEFAULTS);\n  Joint.call(this, def, bodyA, bodyB);\n  bodyA = this.m_bodyA;\n  bodyB = this.m_bodyB;\n\n  this.m_type = DistanceJoint.TYPE;\n\n  // Solver shared\n  this.m_localAnchorA = Vec2.clone(anchorA ? bodyA.getLocalPoint(anchorA) : def.localAnchorA || Vec2.zero());\n  this.m_localAnchorB = Vec2.clone(anchorB ? bodyB.getLocalPoint(anchorB) : def.localAnchorB || Vec2.zero());\n  this.m_length = Math.isFinite(def.length) ? def.length :\n    Vec2.distance(bodyA.getWorldPoint(this.m_localAnchorA), bodyB.getWorldPoint(this.m_localAnchorB));\n  this.m_frequencyHz = def.frequencyHz;\n  this.m_dampingRatio = def.dampingRatio;\n  this.m_impulse = 0.0;\n  this.m_gamma = 0.0;\n  this.m_bias = 0.0;\n\n  // Solver temp\n  this.m_u; // Vec2\n  this.m_rA; // Vec2\n  this.m_rB; // Vec2\n  this.m_localCenterA; // Vec2\n  this.m_localCenterB; // Vec2\n  this.m_invMassA;\n  this.m_invMassB;\n  this.m_invIA;\n  this.m_invIB;\n  this.m_mass;\n\n  // 1-D constrained system\n  // m (v2 - v1) = lambda\n  // v2 + (beta/h) * x1 + gamma * lambda = 0, gamma has units of inverse mass.\n  // x2 = x1 + h * v2\n\n  // 1-D mass-damper-spring system\n  // m (v2 - v1) + h * d * v2 + h * k *\n\n  // C = norm(p2 - p1) - L\n  // u = (p2 - p1) / norm(p2 - p1)\n  // Cdot = dot(u, v2 + cross(w2, r2) - v1 - cross(w1, r1))\n  // J = [-u -cross(r1, u) u cross(r2, u)]\n  // K = J * invM * JT\n  // = invMass1 + invI1 * cross(r1, u)^2 + invMass2 + invI2 * cross(r2, u)^2\n};\n\nDistanceJoint.prototype._serialize = function() {\n  return {\n    type: this.m_type,\n    bodyA: this.m_bodyA,\n    bodyB: this.m_bodyB,\n    collideConnected: this.m_collideConnected,\n\n    frequencyHz: this.m_frequencyHz,\n    dampingRatio: this.m_dampingRatio,\n\n    localAnchorA: this.m_localAnchorA,\n    localAnchorB: this.m_localAnchorB,\n    length: this.m_length,\n\n    impulse: this.m_impulse,\n    gamma: this.m_gamma,\n    bias: this.m_bias,\n  };\n};\n\nDistanceJoint._deserialize = function(data, world, restore) {\n  data = Object.assign({}, data);\n  data.bodyA = restore(Body, data.bodyA, world);\n  data.bodyB = restore(Body, data.bodyB, world);\n  var joint = new DistanceJoint(data);\n  return joint;\n};\n\n/**\n * @internal\n */\nDistanceJoint.prototype._setAnchors = function(def) {\n  if (def.anchorA) {\n    this.m_localAnchorA.set(this.m_bodyA.getLocalPoint(def.anchorA));\n  } else if (def.localAnchorA) {\n    this.m_localAnchorA.set(def.localAnchorA);\n  }\n\n  if (def.anchorB) {\n    this.m_localAnchorB.set(this.m_bodyB.getLocalPoint(def.anchorB));\n  } else if (def.localAnchorB) {\n    this.m_localAnchorB.set(def.localAnchorB);\n  }\n\n  if (def.length > 0) {\n    this.m_length = +def.length;\n  } else if (def.length < 0) { // don't change length\n  } else if (def.anchorA || def.anchorA || def.anchorA || def.anchorA) {\n    this.m_length = Vec2.distance(\n        this.m_bodyA.getWorldPoint(this.m_localAnchorA),\n        this.m_bodyB.getWorldPoint(this.m_localAnchorB)\n    );\n  }\n}\n\n/**\n * The local anchor point relative to bodyA's origin.\n */\nDistanceJoint.prototype.getLocalAnchorA = function() {\n  return this.m_localAnchorA;\n}\n\n/**\n * The local anchor point relative to bodyB's origin.\n */\nDistanceJoint.prototype.getLocalAnchorB = function() {\n  return this.m_localAnchorB;\n}\n\n/**\n * Set/get the natural length. Manipulating the length can lead to non-physical\n * behavior when the frequency is zero.\n */\nDistanceJoint.prototype.setLength = function(length) {\n  this.m_length = length;\n}\n\nDistanceJoint.prototype.getLength = function() {\n  return this.m_length;\n}\n\nDistanceJoint.prototype.setFrequency = function(hz) {\n  this.m_frequencyHz = hz;\n}\n\nDistanceJoint.prototype.getFrequency = function() {\n  return this.m_frequencyHz;\n}\n\nDistanceJoint.prototype.setDampingRatio = function(ratio) {\n  this.m_dampingRatio = ratio;\n}\n\nDistanceJoint.prototype.getDampingRatio = function() {\n  return this.m_dampingRatio;\n}\n\nDistanceJoint.prototype.getAnchorA = function() {\n  return this.m_bodyA.getWorldPoint(this.m_localAnchorA);\n}\n\nDistanceJoint.prototype.getAnchorB = function() {\n  return this.m_bodyB.getWorldPoint(this.m_localAnchorB);\n}\n\nDistanceJoint.prototype.getReactionForce = function(inv_dt) {\n  return Vec2.mul(this.m_impulse, this.m_u).mul(inv_dt);\n}\n\nDistanceJoint.prototype.getReactionTorque = function(inv_dt) {\n  return 0.0;\n}\n\nDistanceJoint.prototype.initVelocityConstraints = function(step) {\n  this.m_localCenterA = this.m_bodyA.m_sweep.localCenter;\n  this.m_localCenterB = this.m_bodyB.m_sweep.localCenter;\n  this.m_invMassA = this.m_bodyA.m_invMass;\n  this.m_invMassB = this.m_bodyB.m_invMass;\n  this.m_invIA = this.m_bodyA.m_invI;\n  this.m_invIB = this.m_bodyB.m_invI;\n\n  var cA = this.m_bodyA.c_position.c;\n  var aA = this.m_bodyA.c_position.a;\n  var vA = this.m_bodyA.c_velocity.v;\n  var wA = this.m_bodyA.c_velocity.w;\n\n  var cB = this.m_bodyB.c_position.c;\n  var aB = this.m_bodyB.c_position.a;\n  var vB = this.m_bodyB.c_velocity.v;\n  var wB = this.m_bodyB.c_velocity.w;\n\n  var qA = Rot.neo(aA);\n  var qB = Rot.neo(aB);\n\n  this.m_rA = Rot.mulVec2(qA, Vec2.sub(this.m_localAnchorA, this.m_localCenterA));\n  this.m_rB = Rot.mulVec2(qB, Vec2.sub(this.m_localAnchorB, this.m_localCenterB));\n  this.m_u = Vec2.sub(Vec2.add(cB, this.m_rB), Vec2.add(cA, this.m_rA));\n\n  // Handle singularity.\n  var length = this.m_u.length();\n  if (length > Settings.linearSlop) {\n    this.m_u.mul(1.0 / length);\n  } else {\n    this.m_u.set(0.0, 0.0);\n  }\n\n  var crAu = Vec2.cross(this.m_rA, this.m_u);\n  var crBu = Vec2.cross(this.m_rB, this.m_u);\n  var invMass = this.m_invMassA + this.m_invIA * crAu * crAu + this.m_invMassB\n      + this.m_invIB * crBu * crBu;\n\n  // Compute the effective mass matrix.\n  this.m_mass = invMass != 0.0 ? 1.0 / invMass : 0.0;\n\n  if (this.m_frequencyHz > 0.0) {\n    var C = length - this.m_length;\n\n    // Frequency\n    var omega = 2.0 * Math.PI * this.m_frequencyHz;\n\n    // Damping coefficient\n    var d = 2.0 * this.m_mass * this.m_dampingRatio * omega;\n\n    // Spring stiffness\n    var k = this.m_mass * omega * omega;\n\n    // magic formulas\n    var h = step.dt;\n    this.m_gamma = h * (d + h * k);\n    this.m_gamma = this.m_gamma != 0.0 ? 1.0 / this.m_gamma : 0.0;\n    this.m_bias = C * h * k * this.m_gamma;\n\n    invMass += this.m_gamma;\n    this.m_mass = invMass != 0.0 ? 1.0 / invMass : 0.0;\n  } else {\n    this.m_gamma = 0.0;\n    this.m_bias = 0.0;\n  }\n\n  if (step.warmStarting) {\n    // Scale the impulse to support a variable time step.\n    this.m_impulse *= step.dtRatio;\n\n    var P = Vec2.mul(this.m_impulse, this.m_u);\n\n    vA.subMul(this.m_invMassA, P);\n    wA -= this.m_invIA * Vec2.cross(this.m_rA, P);\n\n    vB.addMul(this.m_invMassB, P);\n    wB += this.m_invIB * Vec2.cross(this.m_rB, P);\n\n  } else {\n    this.m_impulse = 0.0;\n  }\n\n  this.m_bodyA.c_velocity.v.set(vA);\n  this.m_bodyA.c_velocity.w = wA;\n  this.m_bodyB.c_velocity.v.set(vB);\n  this.m_bodyB.c_velocity.w = wB;\n}\n\nDistanceJoint.prototype.solveVelocityConstraints = function(step) {\n  var vA = this.m_bodyA.c_velocity.v;\n  var wA = this.m_bodyA.c_velocity.w;\n  var vB = this.m_bodyB.c_velocity.v;\n  var wB = this.m_bodyB.c_velocity.w;\n\n  // Cdot = dot(u, v + cross(w, r))\n  var vpA = Vec2.add(vA, Vec2.cross(wA, this.m_rA));\n  var vpB = Vec2.add(vB, Vec2.cross(wB, this.m_rB));\n  var Cdot = Vec2.dot(this.m_u, vpB) - Vec2.dot(this.m_u, vpA);\n\n  var impulse = -this.m_mass\n      * (Cdot + this.m_bias + this.m_gamma * this.m_impulse);\n  this.m_impulse += impulse;\n\n  var P = Vec2.mul(impulse, this.m_u);\n  vA.subMul(this.m_invMassA, P);\n  wA -= this.m_invIA * Vec2.cross(this.m_rA, P);\n  vB.addMul(this.m_invMassB, P);\n  wB += this.m_invIB * Vec2.cross(this.m_rB, P);\n\n  this.m_bodyA.c_velocity.v.set(vA);\n  this.m_bodyA.c_velocity.w = wA;\n  this.m_bodyB.c_velocity.v.set(vB);\n  this.m_bodyB.c_velocity.w = wB;\n}\n\nDistanceJoint.prototype.solvePositionConstraints = function(step) {\n  if (this.m_frequencyHz > 0.0) {\n    // There is no position correction for soft distance constraints.\n    return true;\n  }\n\n  var cA = this.m_bodyA.c_position.c;\n  var aA = this.m_bodyA.c_position.a;\n  var cB = this.m_bodyB.c_position.c;\n  var aB = this.m_bodyB.c_position.a;\n\n  var qA = Rot.neo(aA);\n  var qB = Rot.neo(aB);\n\n  var rA = Rot.mulSub(qA, this.m_localAnchorA, this.m_localCenterA);\n  var rB = Rot.mulSub(qB, this.m_localAnchorB, this.m_localCenterB);\n  var u = Vec2.sub(Vec2.add(cB, rB), Vec2.add(cA, rA));\n\n  var length = u.normalize();\n  var C = length - this.m_length;\n  C = Math\n      .clamp(C, -Settings.maxLinearCorrection, Settings.maxLinearCorrection);\n\n  var impulse = -this.m_mass * C;\n  var P = Vec2.mul(impulse, u);\n\n  cA.subMul(this.m_invMassA, P);\n  aA -= this.m_invIA * Vec2.cross(rA, P);\n  cB.addMul(this.m_invMassB, P);\n  aB += this.m_invIB * Vec2.cross(rB, P);\n\n  this.m_bodyA.c_position.c.set(cA);\n  this.m_bodyA.c_position.a = aA;\n  this.m_bodyB.c_position.c.set(cB);\n  this.m_bodyB.c_position.a = aB;\n\n  return Math.abs(C) < Settings.linearSlop;\n}\n","/*\n * Planck.js\n * The MIT License\n * Copyright (c) 2021 Erin Catto, Ali Shakiba\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 all\n * 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 THE\n * SOFTWARE.\n */\n\nvar _DEBUG = typeof DEBUG === 'undefined' ? false : DEBUG;\nvar _ASSERT = typeof ASSERT === 'undefined' ? false : ASSERT;\n\nmodule.exports = FrictionJoint;\n\nvar common = require('../util/common');\nvar options = require('../util/options');\nvar Settings = require('../Settings');\n\nvar Math = require('../common/Math');\nvar Vec2 = require('../common/Vec2');\nvar Vec3 = require('../common/Vec3');\nvar Mat22 = require('../common/Mat22');\nvar Mat33 = require('../common/Mat33');\nvar Rot = require('../common/Rot');\nvar Sweep = require('../common/Sweep');\nvar Transform = require('../common/Transform');\nvar Velocity = require('../common/Velocity');\nvar Position = require('../common/Position');\n\nvar Joint = require('../Joint');\nvar Body = require('../Body');\n\nFrictionJoint.TYPE = 'friction-joint';\nJoint.TYPES[FrictionJoint.TYPE] = FrictionJoint;\n\nFrictionJoint._super = Joint;\nFrictionJoint.prototype = Object.create(FrictionJoint._super.prototype);\n\n/**\n * @typedef {Object} FrictionJointDef\n *\n * Friction joint definition.\n * \n * @prop {float} maxForce The maximum friction force in N.\n * @prop {float} maxTorque The maximum friction torque in N-m.\n *\n * @prop {Vec2} localAnchorA The local anchor point relative to bodyA's origin.\n * @prop {Vec2} localAnchorB The local anchor point relative to bodyB's origin.\n */\n\nvar DEFAULTS = {\n  maxForce : 0.0,\n  maxTorque : 0.0,\n};\n\n/**\n * Friction joint. This is used for top-down friction. It provides 2D\n * translational friction and angular friction.\n *\n * @param {FrictionJointDef} def\n * @param {Body} bodyA\n * @param {Body} bodyB\n * @param {Vec2} anchor Anchor in global coordination.\n */\nfunction FrictionJoint(def, bodyA, bodyB, anchor) {\n  if (!(this instanceof FrictionJoint)) {\n    return new FrictionJoint(def, bodyA, bodyB, anchor);\n  }\n\n  def = options(def, DEFAULTS);\n  Joint.call(this, def, bodyA, bodyB);\n  bodyA = this.m_bodyA;\n  bodyB = this.m_bodyB;\n\n  this.m_type = FrictionJoint.TYPE;\n\n  this.m_localAnchorA = Vec2.clone(anchor ? bodyA.getLocalPoint(anchor) : def.localAnchorA || Vec2.zero());\n  this.m_localAnchorB = Vec2.clone(anchor ? bodyB.getLocalPoint(anchor) : def.localAnchorB || Vec2.zero());\n\n  // Solver shared\n  this.m_linearImpulse = Vec2.zero();\n  this.m_angularImpulse = 0.0;\n  this.m_maxForce = def.maxForce;\n  this.m_maxTorque = def.maxTorque;\n\n  // Solver temp\n  this.m_rA; // Vec2\n  this.m_rB; // Vec2\n  this.m_localCenterA; // Vec2\n  this.m_localCenterB; // Vec2\n  this.m_invMassA; // float\n  this.m_invMassB; // float\n  this.m_invIA; // float\n  this.m_invIB; // float\n  this.m_linearMass; // Mat22\n  this.m_angularMass; // float\n\n  // Point-to-point constraint\n  // Cdot = v2 - v1\n  // = v2 + cross(w2, r2) - v1 - cross(w1, r1)\n  // J = [-I -r1_skew I r2_skew ]\n  // Identity used:\n  // w k % (rx i + ry j) = w * (-ry i + rx j)\n\n  // Angle constraint\n  // Cdot = w2 - w1\n  // J = [0 0 -1 0 0 1]\n  // K = invI1 + invI2\n}\n\nFrictionJoint.prototype._serialize = function() {\n  return {\n    type: this.m_type,\n    bodyA: this.m_bodyA,\n    bodyB: this.m_bodyB,\n    collideConnected: this.m_collideConnected,\n\n    maxForce: this.m_maxForce,\n    maxTorque: this.m_maxTorque,\n\n    localAnchorA: this.m_localAnchorA,\n    localAnchorB: this.m_localAnchorB,\n  };\n};\n\nFrictionJoint._deserialize = function(data, world, restore) {\n  data = Object.assign({}, data);\n  data.bodyA = restore(Body, data.bodyA, world);\n  data.bodyB = restore(Body, data.bodyB, world);\n  var joint = new FrictionJoint(data);\n  return joint;\n};\n\n/**\n * @internal\n */\nFrictionJoint.prototype._setAnchors = function(def) {\n  if (def.anchorA) {\n    this.m_localAnchorA.set(this.m_bodyA.getLocalPoint(def.anchorA));\n  } else if (def.localAnchorA) {\n    this.m_localAnchorA.set(def.localAnchorA);\n  }\n\n  if (def.anchorB) {\n    this.m_localAnchorB.set(this.m_bodyB.getLocalPoint(def.anchorB));\n  } else if (def.localAnchorB) {\n    this.m_localAnchorB.set(def.localAnchorB);\n  }\n}\n\n\n/**\n * The local anchor point relative to bodyA's origin.\n */\nFrictionJoint.prototype.getLocalAnchorA = function() {\n  return this.m_localAnchorA;\n}\n\n/**\n * The local anchor point relative to bodyB's origin.\n */\nFrictionJoint.prototype.getLocalAnchorB = function() {\n  return this.m_localAnchorB;\n}\n\n/**\n * Set the maximum friction force in N.\n */\nFrictionJoint.prototype.setMaxForce = function(force) {\n  _ASSERT && common.assert(Math.isFinite(force) && force >= 0.0);\n  this.m_maxForce = force;\n}\n\n/**\n * Get the maximum friction force in N.\n */\nFrictionJoint.prototype.getMaxForce = function() {\n  return this.m_maxForce;\n}\n\n/**\n * Set the maximum friction torque in N*m.\n */\nFrictionJoint.prototype.setMaxTorque = function(torque) {\n  _ASSERT && common.assert(Math.isFinite(torque) && torque >= 0.0);\n  this.m_maxTorque = torque;\n}\n\n/**\n * Get the maximum friction torque in N*m.\n */\nFrictionJoint.prototype.getMaxTorque = function() {\n  return this.m_maxTorque;\n}\n\nFrictionJoint.prototype.getAnchorA = function() {\n  return this.m_bodyA.getWorldPoint(this.m_localAnchorA);\n}\n\nFrictionJoint.prototype.getAnchorB = function() {\n  return this.m_bodyB.getWorldPoint(this.m_localAnchorB);\n}\n\nFrictionJoint.prototype.getReactionForce = function(inv_dt) {\n  return Vec2.mul(inv_dt, this.m_linearImpulse);\n}\n\nFrictionJoint.prototype.getReactionTorque = function(inv_dt) {\n  return inv_dt * this.m_angularImpulse;\n}\n\nFrictionJoint.prototype.initVelocityConstraints = function(step) {\n  this.m_localCenterA = this.m_bodyA.m_sweep.localCenter;\n  this.m_localCenterB = this.m_bodyB.m_sweep.localCenter;\n  this.m_invMassA = this.m_bodyA.m_invMass;\n  this.m_invMassB = this.m_bodyB.m_invMass;\n  this.m_invIA = this.m_bodyA.m_invI;\n  this.m_invIB = this.m_bodyB.m_invI;\n\n  var aA = this.m_bodyA.c_position.a;\n  var vA = this.m_bodyA.c_velocity.v;\n  var wA = this.m_bodyA.c_velocity.w;\n\n  var aB = this.m_bodyB.c_position.a;\n  var vB = this.m_bodyB.c_velocity.v;\n  var wB = this.m_bodyB.c_velocity.w;\n\n  var qA = Rot.neo(aA), qB = Rot.neo(aB);\n\n  // Compute the effective mass matrix.\n  this.m_rA = Rot.mulVec2(qA, Vec2.sub(this.m_localAnchorA, this.m_localCenterA));\n  this.m_rB = Rot.mulVec2(qB, Vec2.sub(this.m_localAnchorB, this.m_localCenterB));\n\n  // J = [-I -r1_skew I r2_skew]\n  // [ 0 -1 0 1]\n  // r_skew = [-ry; rx]\n\n  // Matlab\n  // K = [ mA+r1y^2*iA+mB+r2y^2*iB, -r1y*iA*r1x-r2y*iB*r2x, -r1y*iA-r2y*iB]\n  // [ -r1y*iA*r1x-r2y*iB*r2x, mA+r1x^2*iA+mB+r2x^2*iB, r1x*iA+r2x*iB]\n  // [ -r1y*iA-r2y*iB, r1x*iA+r2x*iB, iA+iB]\n\n  var mA = this.m_invMassA, mB = this.m_invMassB; // float\n  var iA = this.m_invIA, iB = this.m_invIB; // float\n\n  var K = new Mat22()\n  K.ex.x = mA + mB + iA * this.m_rA.y * this.m_rA.y + iB * this.m_rB.y\n      * this.m_rB.y;\n  K.ex.y = -iA * this.m_rA.x * this.m_rA.y - iB * this.m_rB.x * this.m_rB.y;\n  K.ey.x = K.ex.y;\n  K.ey.y = mA + mB + iA * this.m_rA.x * this.m_rA.x + iB * this.m_rB.x\n      * this.m_rB.x;\n\n  this.m_linearMass = K.getInverse();\n\n  this.m_angularMass = iA + iB;\n  if (this.m_angularMass > 0.0) {\n    this.m_angularMass = 1.0 / this.m_angularMass;\n  }\n\n  if (step.warmStarting) {\n    // Scale impulses to support a variable time step.\n    this.m_linearImpulse.mul(step.dtRatio);\n    this.m_angularImpulse *= step.dtRatio;\n\n    var P = Vec2.neo(this.m_linearImpulse.x, this.m_linearImpulse.y);\n\n    vA.subMul(mA, P);\n    wA -= iA * (Vec2.cross(this.m_rA, P) + this.m_angularImpulse);\n\n    vB.addMul(mB, P);\n    wB += iB * (Vec2.cross(this.m_rB, P) + this.m_angularImpulse);\n\n  } else {\n    this.m_linearImpulse.setZero();\n    this.m_angularImpulse = 0.0;\n  }\n\n  this.m_bodyA.c_velocity.v = vA;\n  this.m_bodyA.c_velocity.w = wA;\n  this.m_bodyB.c_velocity.v = vB;\n  this.m_bodyB.c_velocity.w = wB;\n}\n\nFrictionJoint.prototype.solveVelocityConstraints = function(step) {\n  var vA = this.m_bodyA.c_velocity.v;\n  var wA = this.m_bodyA.c_velocity.w;\n  var vB = this.m_bodyB.c_velocity.v;\n  var wB = this.m_bodyB.c_velocity.w;\n\n  var mA = this.m_invMassA, mB = this.m_invMassB; // float\n  var iA = this.m_invIA, iB = this.m_invIB; // float\n\n  var h = step.dt; // float\n\n  // Solve angular friction\n  {\n    var Cdot = wB - wA; // float\n    var impulse = -this.m_angularMass * Cdot; // float\n\n    var oldImpulse = this.m_angularImpulse; // float\n    var maxImpulse = h * this.m_maxTorque; // float\n    this.m_angularImpulse = Math.clamp(this.m_angularImpulse + impulse,\n        -maxImpulse, maxImpulse);\n    impulse = this.m_angularImpulse - oldImpulse;\n\n    wA -= iA * impulse;\n    wB += iB * impulse;\n  }\n\n  // Solve linear friction\n  {\n    var Cdot = Vec2.sub(Vec2.add(vB, Vec2.cross(wB, this.m_rB)), Vec2.add(vA,\n        Vec2.cross(wA, this.m_rA))); // Vec2\n\n    var impulse = Vec2.neg(Mat22.mulVec2(this.m_linearMass, Cdot)); // Vec2\n    var oldImpulse = this.m_linearImpulse; // Vec2\n    this.m_linearImpulse.add(impulse);\n\n    var maxImpulse = h * this.m_maxForce; // float\n\n    if (this.m_linearImpulse.lengthSquared() > maxImpulse * maxImpulse) {\n      this.m_linearImpulse.normalize();\n      this.m_linearImpulse.mul(maxImpulse);\n    }\n\n    impulse = Vec2.sub(this.m_linearImpulse, oldImpulse);\n\n    vA.subMul(mA, impulse);\n    wA -= iA * Vec2.cross(this.m_rA, impulse);\n\n    vB.addMul(mB, impulse);\n    wB += iB * Vec2.cross(this.m_rB, impulse);\n  }\n\n  this.m_bodyA.c_velocity.v = vA;\n  this.m_bodyA.c_velocity.w = wA;\n  this.m_bodyB.c_velocity.v = vB;\n  this.m_bodyB.c_velocity.w = wB;\n}\n\nFrictionJoint.prototype.solvePositionConstraints = function(step) {\n  return true;\n}\n","/*\n * Planck.js\n * The MIT License\n * Copyright (c) 2021 Erin Catto, Ali Shakiba\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 all\n * 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 THE\n * SOFTWARE.\n */\n\nvar _DEBUG = typeof DEBUG === 'undefined' ? false : DEBUG;\nvar _ASSERT = typeof ASSERT === 'undefined' ? false : ASSERT;\n\nmodule.exports = GearJoint;\n\nvar common = require('../util/common');\nvar options = require('../util/options');\nvar Settings = require('../Settings');\n\nvar Math = require('../common/Math');\nvar Vec2 = require('../common/Vec2');\nvar Vec3 = require('../common/Vec3');\nvar Mat22 = require('../common/Mat22');\nvar Mat33 = require('../common/Mat33');\nvar Rot = require('../common/Rot');\nvar Sweep = require('../common/Sweep');\nvar Transform = require('../common/Transform');\nvar Velocity = require('../common/Velocity');\nvar Position = require('../common/Position');\n\nvar Joint = require('../Joint');\nvar Body = require('../Body');\n\nvar RevoluteJoint = require('./RevoluteJoint');\nvar PrismaticJoint = require('./PrismaticJoint');\n\nGearJoint.TYPE = 'gear-joint';\nJoint.TYPES[GearJoint.TYPE] = GearJoint;\n\nGearJoint._super = Joint;\nGearJoint.prototype = Object.create(GearJoint._super.prototype);\n\n/**\n * @typedef {Object} GearJointDef\n *\n * Gear joint definition.\n *\n * @prop {float} ratio The gear ratio. See GearJoint for explanation.\n *\n * @prop {RevoluteJoint|PrismaticJoint} joint1 The first revolute/prismatic\n *          joint attached to the gear joint.\n * @prop {PrismaticJoint|RevoluteJoint} joint2 The second prismatic/revolute\n *          joint attached to the gear joint.\n */\n\nvar DEFAULTS = {\n  ratio : 1.0\n};\n\n/**\n * A gear joint is used to connect two joints together. Either joint can be a\n * revolute or prismatic joint. You specify a gear ratio to bind the motions\n * together: coordinate1 + ratio * coordinate2 = constant\n * \n * The ratio can be negative or positive. If one joint is a revolute joint and\n * the other joint is a prismatic joint, then the ratio will have units of\n * length or units of 1/length. Warning: You have to manually destroy the gear\n * joint if joint1 or joint2 is destroyed.\n * \n * This definition requires two existing revolute or prismatic joints (any\n * combination will work).\n *\n * @param {GearJointDef} def\n * @param {Body} bodyA\n * @param {Body} bodyB\n */\nfunction GearJoint(def, bodyA, bodyB, joint1, joint2, ratio) {\n  if (!(this instanceof GearJoint)) {\n    return new GearJoint(def, bodyA, bodyB, joint1, joint2, ratio);\n  }\n\n  def = options(def, DEFAULTS);\n  Joint.call(this, def, bodyA, bodyB);\n  bodyA = this.m_bodyA;\n  bodyB = this.m_bodyB;\n\n  this.m_type = GearJoint.TYPE;\n\n  _ASSERT && common.assert(joint1.m_type === RevoluteJoint.TYPE\n      || joint1.m_type === PrismaticJoint.TYPE);\n  _ASSERT && common.assert(joint2.m_type === RevoluteJoint.TYPE\n      || joint2.m_type === PrismaticJoint.TYPE);\n\n  this.m_joint1 = joint1 ? joint1 : def.joint1;\n  this.m_joint2 = joint2 ? joint2 : def.joint2;\n  this.m_ratio = Math.isFinite(ratio) ? ratio : def.ratio;\n\n  this.m_type1 = this.m_joint1.getType();\n  this.m_type2 = this.m_joint2.getType();\n\n  // joint1 connects body A to body C\n  // joint2 connects body B to body D\n\n  var coordinateA, coordinateB; // float\n\n  // TODO_ERIN there might be some problem with the joint edges in Joint.\n\n  this.m_bodyC = this.m_joint1.getBodyA();\n  this.m_bodyA = this.m_joint1.getBodyB();\n\n  // Get geometry of joint1\n  var xfA = this.m_bodyA.m_xf;\n  var aA = this.m_bodyA.m_sweep.a;\n  var xfC = this.m_bodyC.m_xf;\n  var aC = this.m_bodyC.m_sweep.a;\n\n  if (this.m_type1 === RevoluteJoint.TYPE) {\n    var revolute = this.m_joint1;// RevoluteJoint\n    this.m_localAnchorC = revolute.m_localAnchorA;\n    this.m_localAnchorA = revolute.m_localAnchorB;\n    this.m_referenceAngleA = revolute.m_referenceAngle;\n    this.m_localAxisC = Vec2.zero();\n\n    coordinateA = aA - aC - this.m_referenceAngleA;\n  } else {\n    var prismatic = this.m_joint1; // PrismaticJoint\n    this.m_localAnchorC = prismatic.m_localAnchorA;\n    this.m_localAnchorA = prismatic.m_localAnchorB;\n    this.m_referenceAngleA = prismatic.m_referenceAngle;\n    this.m_localAxisC = prismatic.m_localXAxisA;\n\n    var pC = this.m_localAnchorC;\n    var pA = Rot.mulTVec2(xfC.q, Vec2.add(Rot.mul(xfA.q, this.m_localAnchorA), Vec2.sub(xfA.p, xfC.p)));\n    coordinateA = Vec2.dot(pA, this.m_localAxisC) - Vec2.dot(pC, this.m_localAxisC);\n  }\n\n  this.m_bodyD = this.m_joint2.getBodyA();\n  this.m_bodyB = this.m_joint2.getBodyB();\n\n  // Get geometry of joint2\n  var xfB = this.m_bodyB.m_xf;\n  var aB = this.m_bodyB.m_sweep.a;\n  var xfD = this.m_bodyD.m_xf;\n  var aD = this.m_bodyD.m_sweep.a;\n\n  if (this.m_type2 === RevoluteJoint.TYPE) {\n    var revolute = this.m_joint2; // RevoluteJoint\n    this.m_localAnchorD = revolute.m_localAnchorA;\n    this.m_localAnchorB = revolute.m_localAnchorB;\n    this.m_referenceAngleB = revolute.m_referenceAngle;\n    this.m_localAxisD = Vec2.zero();\n\n    coordinateB = aB - aD - this.m_referenceAngleB;\n  } else {\n    var prismatic = this.m_joint2; // PrismaticJoint\n    this.m_localAnchorD = prismatic.m_localAnchorA;\n    this.m_localAnchorB = prismatic.m_localAnchorB;\n    this.m_referenceAngleB = prismatic.m_referenceAngle;\n    this.m_localAxisD = prismatic.m_localXAxisA;\n\n    var pD = this.m_localAnchorD;\n    var pB = Rot.mulTVec2(xfD.q, Vec2.add(Rot.mul(xfB.q, this.m_localAnchorB), Vec2.sub(xfB.p, xfD.p)));\n    coordinateB = Vec2.dot(pB, this.m_localAxisD) - Vec2.dot(pD, this.m_localAxisD);\n  }\n\n  this.m_constant = coordinateA + this.m_ratio * coordinateB;\n\n  this.m_impulse = 0.0;\n\n  // Solver temp\n  this.m_lcA, this.m_lcB, this.m_lcC, this.m_lcD; // Vec2\n  this.m_mA, this.m_mB, this.m_mC, this.m_mD; // float\n  this.m_iA, this.m_iB, this.m_iC, this.m_iD; // float\n  this.m_JvAC, this.m_JvBD; // Vec2\n  this.m_JwA, this.m_JwB, this.m_JwC, this.m_JwD; // float\n  this.m_mass; // float\n\n  // Gear Joint:\n  // C0 = (coordinate1 + ratio * coordinate2)_initial\n  // C = (coordinate1 + ratio * coordinate2) - C0 = 0\n  // J = [J1 ratio * J2]\n  // K = J * invM * JT\n  // = J1 * invM1 * J1T + ratio * ratio * J2 * invM2 * J2T\n  //\n  // Revolute:\n  // coordinate = rotation\n  // Cdot = angularVelocity\n  // J = [0 0 1]\n  // K = J * invM * JT = invI\n  //\n  // Prismatic:\n  // coordinate = dot(p - pg, ug)\n  // Cdot = dot(v + cross(w, r), ug)\n  // J = [ug cross(r, ug)]\n  // K = J * invM * JT = invMass + invI * cross(r, ug)^2\n};\n\nGearJoint.prototype._serialize = function() {\n  return {\n    type: this.m_type,\n    bodyA: this.m_bodyA,\n    bodyB: this.m_bodyB,\n    collideConnected: this.m_collideConnected,\n\n    joint1: this.m_joint1,\n    joint2: this.m_joint2,\n    ratio: this.m_ratio,\n\n    // _constant: this.m_constant,\n  };\n};\n\nGearJoint._deserialize = function(data, world, restore) {\n  data = Object.assign({}, data);\n  data.bodyA = restore(Body, data.bodyA, world);\n  data.bodyB = restore(Body, data.bodyB, world);\n  data.joint1 = restore(Joint, data.joint1, world);\n  data.joint2 = restore(Joint, data.joint2, world);\n  var joint = new GearJoint(data);\n  // if (data._constant) joint.m_constant = data._constant;\n  return joint;\n};\n\n/**\n * Get the first joint.\n */\nGearJoint.prototype.getJoint1 = function() {\n  return this.m_joint1;\n}\n\n/**\n * Get the second joint.\n */\nGearJoint.prototype.getJoint2 = function() {\n  return this.m_joint2;\n}\n\n/**\n * Set/Get the gear ratio.\n */\nGearJoint.prototype.setRatio = function(ratio) {\n  _ASSERT && common.assert(Math.isFinite(ratio));\n  this.m_ratio = ratio;\n}\n\nGearJoint.prototype.getRatio = function() {\n  return this.m_ratio;\n}\n\nGearJoint.prototype.getAnchorA = function() {\n  return this.m_bodyA.getWorldPoint(this.m_localAnchorA);\n}\n\nGearJoint.prototype.getAnchorB = function() {\n  return this.m_bodyB.getWorldPoint(this.m_localAnchorB);\n}\n\nGearJoint.prototype.getReactionForce = function(inv_dt) {\n  return Vec2.mul(this.m_impulse, this.m_JvAC).mul(inv_dt);\n}\n\nGearJoint.prototype.getReactionTorque = function(inv_dt) {\n  var L = this.m_impulse * this.m_JwA; // float\n  return inv_dt * L;\n}\n\nGearJoint.prototype.initVelocityConstraints = function(step) {\n  this.m_lcA = this.m_bodyA.m_sweep.localCenter;\n  this.m_lcB = this.m_bodyB.m_sweep.localCenter;\n  this.m_lcC = this.m_bodyC.m_sweep.localCenter;\n  this.m_lcD = this.m_bodyD.m_sweep.localCenter;\n  this.m_mA = this.m_bodyA.m_invMass;\n  this.m_mB = this.m_bodyB.m_invMass;\n  this.m_mC = this.m_bodyC.m_invMass;\n  this.m_mD = this.m_bodyD.m_invMass;\n  this.m_iA = this.m_bodyA.m_invI;\n  this.m_iB = this.m_bodyB.m_invI;\n  this.m_iC = this.m_bodyC.m_invI;\n  this.m_iD = this.m_bodyD.m_invI;\n\n  var aA = this.m_bodyA.c_position.a;\n  var vA = this.m_bodyA.c_velocity.v;\n  var wA = this.m_bodyA.c_velocity.w;\n\n  var aB = this.m_bodyB.c_position.a;\n  var vB = this.m_bodyB.c_velocity.v;\n  var wB = this.m_bodyB.c_velocity.w;\n\n  var aC = this.m_bodyC.c_position.a;\n  var vC = this.m_bodyC.c_velocity.v;\n  var wC = this.m_bodyC.c_velocity.w;\n\n  var aD = this.m_bodyD.c_position.a;\n  var vD = this.m_bodyD.c_velocity.v;\n  var wD = this.m_bodyD.c_velocity.w;\n\n  var qA = Rot.neo(aA);\n  var qB = Rot.neo(aB);\n  var qC = Rot.neo(aC);\n  var qD = Rot.neo(aD);\n\n  this.m_mass = 0.0;\n\n  if (this.m_type1 == RevoluteJoint.TYPE) {\n    this.m_JvAC = Vec2.zero();\n    this.m_JwA = 1.0;\n    this.m_JwC = 1.0;\n    this.m_mass += this.m_iA + this.m_iC;\n  } else {\n    var u = Rot.mulVec2(qC, this.m_localAxisC); // Vec2\n    var rC = Rot.mulSub(qC, this.m_localAnchorC, this.m_lcC); // Vec2\n    var rA = Rot.mulSub(qA, this.m_localAnchorA, this.m_lcA); // Vec2\n    this.m_JvAC = u;\n    this.m_JwC = Vec2.cross(rC, u);\n    this.m_JwA = Vec2.cross(rA, u);\n    this.m_mass += this.m_mC + this.m_mA + this.m_iC * this.m_JwC * this.m_JwC + this.m_iA * this.m_JwA * this.m_JwA;\n  }\n\n  if (this.m_type2 == RevoluteJoint.TYPE) {\n    this.m_JvBD = Vec2.zero();\n    this.m_JwB = this.m_ratio;\n    this.m_JwD = this.m_ratio;\n    this.m_mass += this.m_ratio * this.m_ratio * (this.m_iB + this.m_iD);\n  } else {\n    var u = Rot.mulVec2(qD, this.m_localAxisD); // Vec2\n    var rD = Rot.mulSub(qD, this.m_localAnchorD, this.m_lcD); // Vec2\n    var rB = Rot.mulSub(qB, this.m_localAnchorB, this.m_lcB); // Vec2\n    this.m_JvBD = Vec2.mul(this.m_ratio, u);\n    this.m_JwD = this.m_ratio * Vec2.cross(rD, u);\n    this.m_JwB = this.m_ratio * Vec2.cross(rB, u);\n    this.m_mass += this.m_ratio * this.m_ratio * (this.m_mD + this.m_mB) + this.m_iD * this.m_JwD * this.m_JwD + this.m_iB * this.m_JwB * this.m_JwB;\n  }\n\n  // Compute effective mass.\n  this.m_mass = this.m_mass > 0.0 ? 1.0 / this.m_mass : 0.0;\n\n  if (step.warmStarting) {\n    vA.addMul(this.m_mA * this.m_impulse, this.m_JvAC);\n    wA += this.m_iA * this.m_impulse * this.m_JwA;\n    \n    vB.addMul(this.m_mB * this.m_impulse, this.m_JvBD);\n    wB += this.m_iB * this.m_impulse * this.m_JwB;\n    \n    vC.subMul(this.m_mC * this.m_impulse, this.m_JvAC);\n    wC -= this.m_iC * this.m_impulse * this.m_JwC;\n  \n    vD.subMul(this.m_mD * this.m_impulse, this.m_JvBD);\n    wD -= this.m_iD * this.m_impulse * this.m_JwD;\n\n  } else {\n    this.m_impulse = 0.0;\n  }\n\n  this.m_bodyA.c_velocity.v.set(vA);\n  this.m_bodyA.c_velocity.w = wA;\n  this.m_bodyB.c_velocity.v.set(vB);\n  this.m_bodyB.c_velocity.w = wB;\n  this.m_bodyC.c_velocity.v.set(vC);\n  this.m_bodyC.c_velocity.w = wC;\n  this.m_bodyD.c_velocity.v.set(vD);\n  this.m_bodyD.c_velocity.w = wD;\n}\n\nGearJoint.prototype.solveVelocityConstraints = function(step) {\n  var vA = this.m_bodyA.c_velocity.v;\n  var wA = this.m_bodyA.c_velocity.w;\n  var vB = this.m_bodyB.c_velocity.v;\n  var wB = this.m_bodyB.c_velocity.w;\n  var vC = this.m_bodyC.c_velocity.v;\n  var wC = this.m_bodyC.c_velocity.w;\n  var vD = this.m_bodyD.c_velocity.v;\n  var wD = this.m_bodyD.c_velocity.w;\n\n  var Cdot = Vec2.dot(this.m_JvAC, vA) - Vec2.dot(this.m_JvAC, vC)\n      + Vec2.dot(this.m_JvBD, vB) - Vec2.dot(this.m_JvBD, vD); // float\n  Cdot += (this.m_JwA * wA - this.m_JwC * wC)\n      + (this.m_JwB * wB - this.m_JwD * wD);\n\n  var impulse = -this.m_mass * Cdot; // float\n  this.m_impulse += impulse;\n\n  vA.addMul(this.m_mA * impulse, this.m_JvAC);\n  wA += this.m_iA * impulse * this.m_JwA;\n  vB.addMul(this.m_mB * impulse, this.m_JvBD);\n  wB += this.m_iB * impulse * this.m_JwB;\n  vC.subMul(this.m_mC * impulse, this.m_JvAC);\n  wC -= this.m_iC * impulse * this.m_JwC;\n  vD.subMul(this.m_mD * impulse, this.m_JvBD);\n  wD -= this.m_iD * impulse * this.m_JwD;\n\n  this.m_bodyA.c_velocity.v.set(vA);\n  this.m_bodyA.c_velocity.w = wA;\n  this.m_bodyB.c_velocity.v.set(vB);\n  this.m_bodyB.c_velocity.w = wB;\n  this.m_bodyC.c_velocity.v.set(vC);\n  this.m_bodyC.c_velocity.w = wC;\n  this.m_bodyD.c_velocity.v.set(vD);\n  this.m_bodyD.c_velocity.w = wD;\n}\n\nGearJoint.prototype.solvePositionConstraints = function(step) {\n  var cA = this.m_bodyA.c_position.c;\n  var aA = this.m_bodyA.c_position.a;\n  var cB = this.m_bodyB.c_position.c;\n  var aB = this.m_bodyB.c_position.a;\n  var cC = this.m_bodyC.c_position.c;\n  var aC = this.m_bodyC.c_position.a;\n  var cD = this.m_bodyD.c_position.c;\n  var aD = this.m_bodyD.c_position.a;\n\n  var qA = Rot.neo(aA);\n  var qB = Rot.neo(aB);\n  var qC = Rot.neo(aC);\n  var qD = Rot.neo(aD);\n\n  var linearError = 0.0; // float\n\n  var coordinateA, coordinateB; // float\n\n  var JvAC, JvBD; // Vec2\n  var JwA, JwB, JwC, JwD; // float\n  var mass = 0.0; // float\n\n  if (this.m_type1 == RevoluteJoint.TYPE) {\n    JvAC = Vec2.zero();\n    JwA = 1.0;\n    JwC = 1.0;\n    mass += this.m_iA + this.m_iC;\n\n    coordinateA = aA - aC - this.m_referenceAngleA;\n  } else {\n    var u = Rot.mulVec2(qC, this.m_localAxisC); // Vec2\n    var rC = Rot.mulSub(qC, this.m_localAnchorC, this.m_lcC); // Vec2\n    var rA = Rot.mulSub(qA, this.m_localAnchorA, this.m_lcA); // Vec2\n    JvAC = u;\n    JwC = Vec2.cross(rC, u);\n    JwA = Vec2.cross(rA, u);\n    mass += this.m_mC + this.m_mA + this.m_iC * JwC * JwC + this.m_iA * JwA * JwA;\n\n    var pC = Vec2.sub(this.m_localAnchorC, this.m_lcC); // Vec2\n    var pA = Rot.mulTVec2(qC, Vec2.add(rA, Vec2.sub(cA, cC))); // Vec2\n    coordinateA = Vec2.dot(Vec2.sub(pA, pC), this.m_localAxisC);\n  }\n\n  if (this.m_type2 == RevoluteJoint.TYPE) {\n    JvBD = Vec2.zero();\n    JwB = this.m_ratio;\n    JwD = this.m_ratio;\n    mass += this.m_ratio * this.m_ratio * (this.m_iB + this.m_iD);\n\n    coordinateB = aB - aD - this.m_referenceAngleB;\n  } else {\n    var u = Rot.mulVec2(qD, this.m_localAxisD);\n    var rD = Rot.mulSub(qD, this.m_localAnchorD, this.m_lcD);\n    var rB = Rot.mulSub(qB, this.m_localAnchorB, this.m_lcB);\n    JvBD = Vec2.mul(this.m_ratio, u);\n    JwD = this.m_ratio * Vec2.cross(rD, u);\n    JwB = this.m_ratio * Vec2.cross(rB, u);\n    mass += this.m_ratio * this.m_ratio * (this.m_mD + this.m_mB) + this.m_iD\n        * JwD * JwD + this.m_iB * JwB * JwB;\n\n    var pD = Vec2.sub(this.m_localAnchorD, this.m_lcD); // Vec2\n    var pB = Rot.mulTVec2(qD, Vec2.add(rB, Vec2.sub(cB, cD))); // Vec2\n    coordinateB = Vec2.dot(pB, this.m_localAxisD)\n        - Vec2.dot(pD, this.m_localAxisD);\n  }\n\n  var C = (coordinateA + this.m_ratio * coordinateB) - this.m_constant; // float\n\n  var impulse = 0.0; // float\n  if (mass > 0.0) {\n    impulse = -C / mass;\n  }\n\n  cA.addMul(this.m_mA * impulse, JvAC);\n  aA += this.m_iA * impulse * JwA;\n  cB.addMul(this.m_mB * impulse, JvBD);\n  aB += this.m_iB * impulse * JwB;\n  cC.subMul(this.m_mC * impulse, JvAC);\n  aC -= this.m_iC * impulse * JwC;\n  cD.subMul(this.m_mD * impulse, JvBD);\n  aD -= this.m_iD * impulse * JwD;\n\n  this.m_bodyA.c_position.c.set(cA);\n  this.m_bodyA.c_position.a = aA;\n  this.m_bodyB.c_position.c.set(cB);\n  this.m_bodyB.c_position.a = aB;\n  this.m_bodyC.c_position.c.set(cC);\n  this.m_bodyC.c_position.a = aC;\n  this.m_bodyD.c_position.c.set(cD);\n  this.m_bodyD.c_position.a = aD;\n\n  // TODO_ERIN not implemented\n  return linearError < Settings.linearSlop;\n}\n","/*\n * Planck.js\n * The MIT License\n * Copyright (c) 2021 Erin Catto, Ali Shakiba\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 all\n * 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 THE\n * SOFTWARE.\n */\n\nvar _DEBUG = typeof DEBUG === 'undefined' ? false : DEBUG;\nvar _ASSERT = typeof ASSERT === 'undefined' ? false : ASSERT;\n\nmodule.exports = MotorJoint;\n\nvar common = require('../util/common');\nvar options = require('../util/options');\nvar Settings = require('../Settings');\n\nvar Math = require('../common/Math');\nvar Vec2 = require('../common/Vec2');\nvar Vec3 = require('../common/Vec3');\nvar Mat22 = require('../common/Mat22');\nvar Mat33 = require('../common/Mat33');\nvar Rot = require('../common/Rot');\nvar Sweep = require('../common/Sweep');\nvar Transform = require('../common/Transform');\nvar Velocity = require('../common/Velocity');\nvar Position = require('../common/Position');\n\nvar Joint = require('../Joint');\nvar Body = require('../Body');\n\nMotorJoint.TYPE = 'motor-joint';\nJoint.TYPES[MotorJoint.TYPE] = MotorJoint;\n\nMotorJoint._super = Joint;\nMotorJoint.prototype = Object.create(MotorJoint._super.prototype);\n\n/**\n * @typedef {Object} MotorJointDef\n *\n * Motor joint definition.\n * \n * @prop {float} angularOffset The bodyB angle minus bodyA angle in radians.\n * @prop {float} maxForce The maximum motor force in N.\n * @prop {float} maxTorque The maximum motor torque in N-m.\n * @prop {float} correctionFactor Position correction factor in the range [0,1].\n * @prop {Vec2} linearOffset Position of bodyB minus the position of bodyA, in\n *       bodyA's frame, in meters.\n */\n\nvar DEFAULTS = {\n  maxForce : 1.0,\n  maxTorque : 1.0,\n  correctionFactor : 0.3\n};\n\n/**\n * A motor joint is used to control the relative motion between two bodies. A\n * typical usage is to control the movement of a dynamic body with respect to\n * the ground.\n *\n * @param {MotorJointDef} def\n * @param {Body} bodyA\n * @param {Body} bodyB\n */\nfunction MotorJoint(def, bodyA, bodyB) {\n  if (!(this instanceof MotorJoint)) {\n    return new MotorJoint(def, bodyA, bodyB);\n  }\n\n  def = options(def, DEFAULTS);\n  Joint.call(this, def, bodyA, bodyB);\n  bodyA = this.m_bodyA;\n  bodyB = this.m_bodyB;\n\n  this.m_type = MotorJoint.TYPE;\n\n  this.m_linearOffset = Math.isFinite(def.linearOffset) ? def.linearOffset : bodyA.getLocalPoint(bodyB.getPosition());\n  this.m_angularOffset = Math.isFinite(def.angularOffset) ? def.angularOffset : bodyB.getAngle() - bodyA.getAngle();\n\n  this.m_linearImpulse = Vec2.zero();\n  this.m_angularImpulse = 0.0;\n\n  this.m_maxForce = def.maxForce;\n  this.m_maxTorque = def.maxTorque;\n  this.m_correctionFactor = def.correctionFactor;\n\n  // Solver temp\n  this.m_rA; // Vec2\n  this.m_rB; // Vec2\n  this.m_localCenterA; // Vec2\n  this.m_localCenterB; // Vec2\n  this.m_linearError; // Vec2\n  this.m_angularError; // float\n  this.m_invMassA; // float\n  this.m_invMassB; // float\n  this.m_invIA; // float\n  this.m_invIB; // float\n  this.m_linearMass; // Mat22\n  this.m_angularMass; // float\n\n  // Point-to-point constraint\n  // Cdot = v2 - v1\n  // = v2 + cross(w2, r2) - v1 - cross(w1, r1)\n  // J = [-I -r1_skew I r2_skew ]\n  // Identity used:\n  // w k % (rx i + ry j) = w * (-ry i + rx j)\n\n  // Angle constraint\n  // Cdot = w2 - w1\n  // J = [0 0 -1 0 0 1]\n  // K = invI1 + invI2\n}\n\nMotorJoint.prototype._serialize = function() {\n  return {\n    type: this.m_type,\n    bodyA: this.m_bodyA,\n    bodyB: this.m_bodyB,\n    collideConnected: this.m_collideConnected,\n\n    maxForce: this.m_maxForce,\n    maxTorque: this.m_maxTorque,\n    correctionFactor: this.m_correctionFactor,\n\n    linearOffset: this.m_linearOffset,\n    angularOffset: this.m_angularOffset,\n  };\n};\n\nMotorJoint._deserialize = function(data, world, restore) {\n  data = Object.assign({}, data);\n  data.bodyA = restore(Body, data.bodyA, world);\n  data.bodyB = restore(Body, data.bodyB, world);\n  var joint = new MotorJoint(data);\n  return joint;\n};\n\n/**\n * @internal\n */\nMotorJoint.prototype._setAnchors = function(def) {\n  if (def.anchorA) {\n    this.m_localAnchorA.set(this.m_bodyA.getLocalPoint(def.anchorA));\n  } else if (def.localAnchorA) {\n    this.m_localAnchorA.set(def.localAnchorA);\n  }\n\n  if (def.anchorB) {\n    this.m_localAnchorB.set(this.m_bodyB.getLocalPoint(def.anchorB));\n  } else if (def.localAnchorB) {\n    this.m_localAnchorB.set(def.localAnchorB);\n  }\n}\n\n/**\n * Set the maximum friction force in N.\n */\nMotorJoint.prototype.setMaxForce = function(force) {\n  _ASSERT && common.assert(Math.isFinite(force) && force >= 0.0);\n  this.m_maxForce = force;\n}\n\n/**\n * Get the maximum friction force in N.\n */\nMotorJoint.prototype.getMaxForce = function() {\n  return this.m_maxForce;\n}\n\n/**\n * Set the maximum friction torque in N*m.\n */\nMotorJoint.prototype.setMaxTorque = function(torque) {\n  _ASSERT && common.assert(Math.isFinite(torque) && torque >= 0.0);\n  this.m_maxTorque = torque;\n}\n\n/**\n * Get the maximum friction torque in N*m.\n */\nMotorJoint.prototype.getMaxTorque = function() {\n  return this.m_maxTorque;\n}\n\n/**\n * Set the position correction factor in the range [0,1].\n */\nMotorJoint.prototype.setCorrectionFactor = function(factor) {\n  _ASSERT && common.assert(Math.isFinite(factor) && 0.0 <= factor && factor <= 1.0);\n  this.m_correctionFactor = factor;\n}\n\n/**\n * Get the position correction factor in the range [0,1].\n */\nMotorJoint.prototype.getCorrectionFactor = function() {\n  return this.m_correctionFactor;\n}\n\n/**\n * Set/get the target linear offset, in frame A, in meters.\n */\nMotorJoint.prototype.setLinearOffset = function(linearOffset) {\n  if (linearOffset.x != this.m_linearOffset.x\n      || linearOffset.y != this.m_linearOffset.y) {\n    this.m_bodyA.setAwake(true);\n    this.m_bodyB.setAwake(true);\n    this.m_linearOffset = linearOffset;\n  }\n}\n\nMotorJoint.prototype.getLinearOffset = function() {\n  return this.m_linearOffset;\n}\n\n/**\n * Set/get the target angular offset, in radians.\n */\nMotorJoint.prototype.setAngularOffset = function(angularOffset) {\n  if (angularOffset != this.m_angularOffset) {\n    this.m_bodyA.setAwake(true);\n    this.m_bodyB.setAwake(true);\n    this.m_angularOffset = angularOffset;\n  }\n}\n\nMotorJoint.prototype.getAngularOffset = function() {\n  return this.m_angularOffset;\n}\n\nMotorJoint.prototype.getAnchorA = function() {\n  return this.m_bodyA.getPosition();\n}\n\nMotorJoint.prototype.getAnchorB = function() {\n  return this.m_bodyB.getPosition();\n}\n\nMotorJoint.prototype.getReactionForce = function(inv_dt) {\n  return Vec2.mul(inv_dt, this.m_linearImpulse);\n}\n\nMotorJoint.prototype.getReactionTorque = function(inv_dt) {\n  return inv_dt * this.m_angularImpulse;\n}\n\nMotorJoint.prototype.initVelocityConstraints = function(step) {\n  this.m_localCenterA = this.m_bodyA.m_sweep.localCenter;\n  this.m_localCenterB = this.m_bodyB.m_sweep.localCenter;\n  this.m_invMassA = this.m_bodyA.m_invMass;\n  this.m_invMassB = this.m_bodyB.m_invMass;\n  this.m_invIA = this.m_bodyA.m_invI;\n  this.m_invIB = this.m_bodyB.m_invI;\n\n  var cA = this.m_bodyA.c_position.c;\n  var aA = this.m_bodyA.c_position.a;\n  var vA = this.m_bodyA.c_velocity.v;\n  var wA = this.m_bodyA.c_velocity.w;\n\n  var cB = this.m_bodyB.c_position.c;\n  var aB = this.m_bodyB.c_position.a;\n  var vB = this.m_bodyB.c_velocity.v;\n  var wB = this.m_bodyB.c_velocity.w;\n\n  var qA = Rot.neo(aA), qB = Rot.neo(aB);\n\n  // Compute the effective mass matrix.\n  this.m_rA = Rot.mulVec2(qA, Vec2.neg(this.m_localCenterA));\n  this.m_rB = Rot.mulVec2(qB, Vec2.neg(this.m_localCenterB));\n\n  // J = [-I -r1_skew I r2_skew]\n  // [ 0 -1 0 1]\n  // r_skew = [-ry; rx]\n\n  // Matlab\n  // K = [ mA+r1y^2*iA+mB+r2y^2*iB, -r1y*iA*r1x-r2y*iB*r2x, -r1y*iA-r2y*iB]\n  // [ -r1y*iA*r1x-r2y*iB*r2x, mA+r1x^2*iA+mB+r2x^2*iB, r1x*iA+r2x*iB]\n  // [ -r1y*iA-r2y*iB, r1x*iA+r2x*iB, iA+iB]\n\n  var mA = this.m_invMassA;\n  var mB = this.m_invMassB;\n  var iA = this.m_invIA;\n  var iB = this.m_invIB;\n\n  var K = new Mat22();\n  K.ex.x = mA + mB + iA * this.m_rA.y * this.m_rA.y + iB * this.m_rB.y\n      * this.m_rB.y;\n  K.ex.y = -iA * this.m_rA.x * this.m_rA.y - iB * this.m_rB.x * this.m_rB.y;\n  K.ey.x = K.ex.y;\n  K.ey.y = mA + mB + iA * this.m_rA.x * this.m_rA.x + iB * this.m_rB.x\n      * this.m_rB.x;\n\n  this.m_linearMass = K.getInverse();\n\n  this.m_angularMass = iA + iB;\n  if (this.m_angularMass > 0.0) {\n    this.m_angularMass = 1.0 / this.m_angularMass;\n  }\n\n  this.m_linearError = Vec2.zero();\n  this.m_linearError.addCombine(1, cB, 1, this.m_rB);\n  this.m_linearError.subCombine(1, cA, 1, this.m_rA);\n  this.m_linearError.sub(Rot.mulVec2(qA, this.m_linearOffset));\n\n  this.m_angularError = aB - aA - this.m_angularOffset;\n\n  if (step.warmStarting) {\n    // Scale impulses to support a variable time step.\n    this.m_linearImpulse.mul(step.dtRatio);\n    this.m_angularImpulse *= step.dtRatio;\n\n    var P = Vec2.neo(this.m_linearImpulse.x, this.m_linearImpulse.y);\n\n    vA.subMul(mA, P);\n    wA -= iA * (Vec2.cross(this.m_rA, P) + this.m_angularImpulse);\n\n    vB.addMul(mB, P);\n    wB += iB * (Vec2.cross(this.m_rB, P) + this.m_angularImpulse);\n\n  } else {\n    this.m_linearImpulse.setZero();\n    this.m_angularImpulse = 0.0;\n  }\n\n  this.m_bodyA.c_velocity.v = vA;\n  this.m_bodyA.c_velocity.w = wA;\n  this.m_bodyB.c_velocity.v = vB;\n  this.m_bodyB.c_velocity.w = wB;\n}\n\nMotorJoint.prototype.solveVelocityConstraints = function(step) {\n  var vA = this.m_bodyA.c_velocity.v;\n  var wA = this.m_bodyA.c_velocity.w;\n  var vB = this.m_bodyB.c_velocity.v;\n  var wB = this.m_bodyB.c_velocity.w;\n\n  var mA = this.m_invMassA, mB = this.m_invMassB;\n  var iA = this.m_invIA, iB = this.m_invIB;\n\n  var h = step.dt;\n  var inv_h = step.inv_dt;\n\n  // Solve angular friction\n  {\n    var Cdot = wB - wA + inv_h * this.m_correctionFactor * this.m_angularError;\n    var impulse = -this.m_angularMass * Cdot;\n\n    var oldImpulse = this.m_angularImpulse;\n    var maxImpulse = h * this.m_maxTorque;\n    this.m_angularImpulse = Math.clamp(this.m_angularImpulse + impulse,\n        -maxImpulse, maxImpulse);\n    impulse = this.m_angularImpulse - oldImpulse;\n\n    wA -= iA * impulse;\n    wB += iB * impulse;\n  }\n\n  // Solve linear friction\n  {\n    var Cdot = Vec2.zero();\n    Cdot.addCombine(1, vB, 1, Vec2.cross(wB, this.m_rB));\n    Cdot.subCombine(1, vA, 1, Vec2.cross(wA, this.m_rA));\n    Cdot.addMul(inv_h * this.m_correctionFactor, this.m_linearError);\n\n    var impulse = Vec2.neg(Mat22.mulVec2(this.m_linearMass, Cdot));\n    var oldImpulse = Vec2.clone(this.m_linearImpulse);\n    this.m_linearImpulse.add(impulse);\n\n    var maxImpulse = h * this.m_maxForce;\n\n    this.m_linearImpulse.clamp(maxImpulse);\n\n    impulse = Vec2.sub(this.m_linearImpulse, oldImpulse);\n\n    vA.subMul(mA, impulse);\n    wA -= iA * Vec2.cross(this.m_rA, impulse);\n\n    vB.addMul(mB, impulse);\n    wB += iB * Vec2.cross(this.m_rB, impulse);\n  }\n\n  this.m_bodyA.c_velocity.v = vA;\n  this.m_bodyA.c_velocity.w = wA;\n  this.m_bodyB.c_velocity.v = vB;\n  this.m_bodyB.c_velocity.w = wB;\n}\n\nMotorJoint.prototype.solvePositionConstraints = function(step) {\n  return true;\n}\n","/*\n * Planck.js\n * The MIT License\n * Copyright (c) 2021 Erin Catto, Ali Shakiba\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 all\n * 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 THE\n * SOFTWARE.\n */\n\nvar _DEBUG = typeof DEBUG === 'undefined' ? false : DEBUG;\nvar _ASSERT = typeof ASSERT === 'undefined' ? false : ASSERT;\n\nmodule.exports = MouseJoint;\n\nvar common = require('../util/common');\nvar options = require('../util/options');\n\nvar Math = require('../common/Math');\nvar Vec2 = require('../common/Vec2');\nvar Vec3 = require('../common/Vec3');\nvar Mat22 = require('../common/Mat22');\nvar Mat33 = require('../common/Mat33');\nvar Rot = require('../common/Rot');\nvar Sweep = require('../common/Sweep');\nvar Transform = require('../common/Transform');\nvar Velocity = require('../common/Velocity');\nvar Position = require('../common/Position');\n\nvar Joint = require('../Joint');\nvar Body = require('../Body');\n\nMouseJoint.TYPE = 'mouse-joint';\nJoint.TYPES[MouseJoint.TYPE] = MouseJoint;\n\nMouseJoint._super = Joint;\nMouseJoint.prototype = Object.create(MouseJoint._super.prototype);\n\n/**\n * @typedef {Object} MouseJointDef\n *\n * Mouse joint definition. This requires a world target point, tuning\n * parameters, and the time step.\n * \n * @prop [maxForce = 0.0] The maximum constraint force that can be exerted to\n *       move the candidate body. Usually you will express as some multiple of\n *       the weight (multiplier * mass * gravity).\n * @prop [frequencyHz = 5.0] The response speed.\n * @prop [dampingRatio = 0.7] The damping ratio. 0 = no damping, 1 = critical\n *       damping.\n *\n * @prop {Vec2} target The initial world target point. This is assumed to\n *       coincide with the body anchor initially.\n */\n\nvar DEFAULTS = {\n  maxForce : 0.0,\n  frequencyHz : 5.0,\n  dampingRatio : 0.7\n};\n\n/**\n * A mouse joint is used to make a point on a body track a specified world\n * point. This a soft constraint with a maximum force. This allows the\n * constraint to stretch and without applying huge forces.\n * \n * NOTE: this joint is not documented in the manual because it was developed to\n * be used in the testbed. If you want to learn how to use the mouse joint, look\n * at the testbed.\n *\n * @param {MouseJointDef} def\n * @param {Body} bodyA\n * @param {Body} bodyB\n */\nfunction MouseJoint(def, bodyA, bodyB, target) {\n  if (!(this instanceof MouseJoint)) {\n    return new MouseJoint(def, bodyA, bodyB, target);\n  }\n\n  def = options(def, DEFAULTS);\n  Joint.call(this, def, bodyA, bodyB);\n  bodyA = this.m_bodyA;\n  bodyB = this.m_bodyB;\n\n  this.m_type = MouseJoint.TYPE;\n\n  _ASSERT && common.assert(Math.isFinite(def.maxForce) && def.maxForce >= 0.0);\n  _ASSERT && common.assert(Math.isFinite(def.frequencyHz) && def.frequencyHz >= 0.0);\n  _ASSERT && common.assert(Math.isFinite(def.dampingRatio) && def.dampingRatio >= 0.0);\n\n  this.m_targetA = target ? Vec2.clone(target) : def.target || Vec2.zero();\n  this.m_localAnchorB = Transform.mulTVec2(bodyB.getTransform(), this.m_targetA);\n\n  this.m_maxForce = def.maxForce;\n  this.m_impulse = Vec2.zero();\n\n  this.m_frequencyHz = def.frequencyHz;\n  this.m_dampingRatio = def.dampingRatio;\n\n  this.m_beta = 0.0;\n  this.m_gamma = 0.0;\n\n  // Solver temp\n  this.m_rB = Vec2.zero();\n  this.m_localCenterB = Vec2.zero();\n  this.m_invMassB = 0.0;\n  this.m_invIB = 0.0;\n  this.mass = new Mat22()\n  this.m_C = Vec2.zero();\n\n  // p = attached point, m = mouse point\n  // C = p - m\n  // Cdot = v\n  // = v + cross(w, r)\n  // J = [I r_skew]\n  // Identity used:\n  // w k % (rx i + ry j) = w * (-ry i + rx j)\n}\n\nMouseJoint.prototype._serialize = function() {\n  return {\n    type: this.m_type,\n    bodyA: this.m_bodyA,\n    bodyB: this.m_bodyB,\n    collideConnected: this.m_collideConnected,\n\n    target: this.m_targetA,\n    maxForce: this.m_maxForce,\n    frequencyHz: this.m_frequencyHz,\n    dampingRatio: this.m_dampingRatio,\n\n    _localAnchorB: this.m_localAnchorB,\n  };\n};\n\nMouseJoint._deserialize = function(data, world, restore) {\n  data = Object.assign({}, data);\n  data.bodyA = restore(Body, data.bodyA, world);\n  data.bodyB = restore(Body, data.bodyB, world);\n  data.target = Vec2(data.target);\n  var joint = new MouseJoint(data);\n  if (data._localAnchorB) {\n    joint.m_localAnchorB = data._localAnchorB;\n  }\n  return joint;\n};\n\n/**\n * Use this to update the target point.\n */\nMouseJoint.prototype.setTarget = function(target) {\n  if (this.m_bodyB.isAwake() == false) {\n    this.m_bodyB.setAwake(true);\n  }\n  this.m_targetA = Vec2.clone(target);\n}\n\nMouseJoint.prototype.getTarget = function() {\n  return this.m_targetA;\n}\n\n/**\n * Set/get the maximum force in Newtons.\n */\nMouseJoint.prototype.setMaxForce = function(force) {\n  this.m_maxForce = force;\n}\n\nMouseJoint.getMaxForce = function() {\n  return this.m_maxForce;\n}\n\n/**\n * Set/get the frequency in Hertz.\n */\nMouseJoint.prototype.setFrequency = function(hz) {\n  this.m_frequencyHz = hz;\n}\n\nMouseJoint.prototype.getFrequency = function() {\n  return this.m_frequencyHz;\n}\n\n/**\n * Set/get the damping ratio (dimensionless).\n */\nMouseJoint.prototype.setDampingRatio = function(ratio) {\n  this.m_dampingRatio = ratio;\n}\n\nMouseJoint.prototype.getDampingRatio = function() {\n  return this.m_dampingRatio;\n}\n\nMouseJoint.prototype.getAnchorA = function() {\n  return Vec2.clone(this.m_targetA);\n}\n\nMouseJoint.prototype.getAnchorB = function() {\n  return this.m_bodyB.getWorldPoint(this.m_localAnchorB);\n}\n\nMouseJoint.prototype.getReactionForce = function(inv_dt) {\n  return Vec2.mul(inv_dt, this.m_impulse);\n}\n\nMouseJoint.prototype.getReactionTorque = function(inv_dt) {\n  return inv_dt * 0.0;\n}\n\nMouseJoint.prototype.shiftOrigin = function(newOrigin) {\n  this.m_targetA.sub(newOrigin);\n}\n\nMouseJoint.prototype.initVelocityConstraints = function(step) {\n  this.m_localCenterB = this.m_bodyB.m_sweep.localCenter;\n  this.m_invMassB = this.m_bodyB.m_invMass;\n  this.m_invIB = this.m_bodyB.m_invI;\n\n  var position = this.m_bodyB.c_position;\n  var velocity = this.m_bodyB.c_velocity;\n\n  var cB = position.c;\n  var aB = position.a;\n  var vB = velocity.v;\n  var wB = velocity.w;\n\n  var qB = Rot.neo(aB);\n\n  var mass = this.m_bodyB.getMass();\n\n  // Frequency\n  var omega = 2.0 * Math.PI * this.m_frequencyHz;\n\n  // Damping coefficient\n  var d = 2.0 * mass * this.m_dampingRatio * omega;\n\n  // Spring stiffness\n  var k = mass * (omega * omega);\n\n  // magic formulas\n  // gamma has units of inverse mass.\n  // beta has units of inverse time.\n  var h = step.dt;\n  _ASSERT && common.assert(d + h * k > Math.EPSILON);\n  this.m_gamma = h * (d + h * k);\n  if (this.m_gamma != 0.0) {\n    this.m_gamma = 1.0 / this.m_gamma;\n  }\n  this.m_beta = h * k * this.m_gamma;\n\n  // Compute the effective mass matrix.\n  this.m_rB = Rot.mulVec2(qB, Vec2.sub(this.m_localAnchorB, this.m_localCenterB));\n\n  // K = [(1/m1 + 1/m2) * eye(2) - skew(r1) * invI1 * skew(r1) - skew(r2) *\n  // invI2 * skew(r2)]\n  // = [1/m1+1/m2 0 ] + invI1 * [r1.y*r1.y -r1.x*r1.y] + invI2 * [r1.y*r1.y\n  // -r1.x*r1.y]\n  // [ 0 1/m1+1/m2] [-r1.x*r1.y r1.x*r1.x] [-r1.x*r1.y r1.x*r1.x]\n  var K = new Mat22();\n  K.ex.x = this.m_invMassB + this.m_invIB * this.m_rB.y * this.m_rB.y\n      + this.m_gamma;\n  K.ex.y = -this.m_invIB * this.m_rB.x * this.m_rB.y;\n  K.ey.x = K.ex.y;\n  K.ey.y = this.m_invMassB + this.m_invIB * this.m_rB.x * this.m_rB.x\n      + this.m_gamma;\n\n  this.m_mass = K.getInverse();\n\n  this.m_C.set(cB);\n  this.m_C.addCombine(1, this.m_rB, -1, this.m_targetA);\n  this.m_C.mul(this.m_beta);\n\n  // Cheat with some damping\n  wB *= 0.98;\n\n  if (step.warmStarting) {\n    this.m_impulse.mul(step.dtRatio);\n    vB.addMul(this.m_invMassB, this.m_impulse);\n    wB += this.m_invIB * Vec2.cross(this.m_rB, this.m_impulse);\n\n  } else {\n    this.m_impulse.setZero();\n  }\n\n  velocity.v.set(vB);\n  velocity.w = wB;\n}\n\nMouseJoint.prototype.solveVelocityConstraints = function(step) {\n  var velocity = this.m_bodyB.c_velocity;\n  var vB = Vec2.clone(velocity.v);\n  var wB = velocity.w;\n\n  // Cdot = v + cross(w, r)\n\n  var Cdot = Vec2.cross(wB, this.m_rB);\n  Cdot.add(vB);\n\n  Cdot.addCombine(1, this.m_C, this.m_gamma, this.m_impulse);\n  Cdot.neg();\n\n  var impulse = Mat22.mulVec2(this.m_mass, Cdot);\n\n  var oldImpulse = Vec2.clone(this.m_impulse);\n  this.m_impulse.add(impulse);\n  var maxImpulse = step.dt * this.m_maxForce;\n  this.m_impulse.clamp(maxImpulse);\n  impulse = Vec2.sub(this.m_impulse, oldImpulse);\n\n  vB.addMul(this.m_invMassB, impulse);\n  wB += this.m_invIB * Vec2.cross(this.m_rB, impulse);\n\n  velocity.v.set(vB);\n  velocity.w = wB;\n}\n\nMouseJoint.prototype.solvePositionConstraints = function(step) {\n  return true;\n}\n","/*\n * Planck.js\n * The MIT License\n * Copyright (c) 2021 Erin Catto, Ali Shakiba\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 all\n * 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 THE\n * SOFTWARE.\n */\n\nvar _DEBUG = typeof DEBUG === 'undefined' ? false : DEBUG;\nvar _ASSERT = typeof ASSERT === 'undefined' ? false : ASSERT;\n\nmodule.exports = PrismaticJoint;\n\nvar common = require('../util/common');\nvar options = require('../util/options');\nvar Settings = require('../Settings');\n\nvar Math = require('../common/Math');\nvar Vec2 = require('../common/Vec2');\nvar Vec3 = require('../common/Vec3');\nvar Mat22 = require('../common/Mat22');\nvar Mat33 = require('../common/Mat33');\nvar Rot = require('../common/Rot');\nvar Sweep = require('../common/Sweep');\nvar Transform = require('../common/Transform');\nvar Velocity = require('../common/Velocity');\nvar Position = require('../common/Position');\n\nvar Joint = require('../Joint');\nvar Body = require('../Body');\n\nvar inactiveLimit = 0;\nvar atLowerLimit = 1;\nvar atUpperLimit = 2;\nvar equalLimits = 3;\n\nPrismaticJoint.TYPE = 'prismatic-joint';\nJoint.TYPES[PrismaticJoint.TYPE] = PrismaticJoint;\n\nPrismaticJoint._super = Joint;\nPrismaticJoint.prototype = Object.create(PrismaticJoint._super.prototype);\n\n/**\n * @typedef {Object} PrismaticJointDef\n *\n * Prismatic joint definition. This requires defining a line of motion using an\n * axis and an anchor point. The definition uses local anchor points and a local\n * axis so that the initial configuration can violate the constraint slightly.\n * The joint translation is zero when the local anchor points coincide in world\n * space. Using local anchors and a local axis helps when saving and loading a\n * game.\n * \n * @prop {boolean} enableLimit Enable/disable the joint limit.\n * @prop {float} lowerTranslation The lower translation limit, usually in\n *       meters.\n * @prop {float} upperTranslation The upper translation limit, usually in\n *       meters.\n * @prop {boolean} enableMotor Enable/disable the joint motor.\n * @prop {float} maxMotorForce The maximum motor torque, usually in N-m.\n * @prop {float} motorSpeed The desired motor speed in radians per second.\n *\n * @prop {Vec2} localAnchorA The local anchor point relative to bodyA's origin.\n * @prop {Vec2} localAnchorB The local anchor point relative to bodyB's origin.\n * @prop {Vec2} localAxisA The local translation unit axis in bodyA.\n * @prop {float} referenceAngle The constrained angle between the bodies:\n *       bodyB_angle - bodyA_angle.\n */\n\nvar DEFAULTS = {\n  enableLimit : false,\n  lowerTranslation : 0.0,\n  upperTranslation : 0.0,\n  enableMotor : false,\n  maxMotorForce : 0.0,\n  motorSpeed : 0.0\n};\n\n/**\n * A prismatic joint. This joint provides one degree of freedom: translation\n * along an axis fixed in bodyA. Relative rotation is prevented. You can use a\n * joint limit to restrict the range of motion and a joint motor to drive the\n * motion or to model joint friction.\n *\n * @param {PrismaticJointDef} def\n * @param {Body} bodyA\n * @param {Body} bodyB\n */\nfunction PrismaticJoint(def, bodyA, bodyB, anchor, axis) {\n  if (!(this instanceof PrismaticJoint)) {\n    return new PrismaticJoint(def, bodyA, bodyB, anchor, axis);\n  }\n\n  def = options(def, DEFAULTS);\n  Joint.call(this, def, bodyA, bodyB);\n  bodyA = this.m_bodyA;\n  bodyB = this.m_bodyB;\n\n  this.m_type = PrismaticJoint.TYPE;\n\n  this.m_localAnchorA = Vec2.clone(anchor ? bodyA.getLocalPoint(anchor) : def.localAnchorA || Vec2.zero());\n  this.m_localAnchorB = Vec2.clone(anchor ? bodyB.getLocalPoint(anchor) : def.localAnchorB || Vec2.zero());\n  this.m_localXAxisA = Vec2.clone(axis ? bodyA.getLocalVector(axis) : def.localAxisA || Vec2.neo(1.0, 0.0));\n  this.m_localXAxisA.normalize();\n  this.m_localYAxisA = Vec2.cross(1.0, this.m_localXAxisA);\n  this.m_referenceAngle = Math.isFinite(def.referenceAngle) ? def.referenceAngle : bodyB.getAngle() - bodyA.getAngle();\n\n  this.m_impulse = Vec3();\n  this.m_motorMass = 0.0;\n  this.m_motorImpulse = 0.0;\n\n  this.m_lowerTranslation = def.lowerTranslation;\n  this.m_upperTranslation = def.upperTranslation;\n  this.m_maxMotorForce = def.maxMotorForce;\n  this.m_motorSpeed = def.motorSpeed;\n  this.m_enableLimit = def.enableLimit;\n  this.m_enableMotor = def.enableMotor;\n  this.m_limitState = inactiveLimit;\n\n  this.m_axis = Vec2.zero();\n  this.m_perp = Vec2.zero();\n\n  // Solver temp\n  this.m_localCenterA; // Vec2\n  this.m_localCenterB; // Vec2\n  this.m_invMassA; // float\n  this.m_invMassB; // float\n  this.m_invIA; // float\n  this.m_invIB; // float\n  this.m_axis, this.m_perp; // Vec2\n  this.m_s1, this.m_s2; // float\n  this.m_a1, this.m_a2; // float\n  this.m_K = new Mat33();\n  this.m_motorMass; // float\n\n  // Linear constraint (point-to-line)\n  // d = p2 - p1 = x2 + r2 - x1 - r1\n  // C = dot(perp, d)\n  // Cdot = dot(d, cross(w1, perp)) + dot(perp, v2 + cross(w2, r2) - v1 -\n  // cross(w1, r1))\n  // = -dot(perp, v1) - dot(cross(d + r1, perp), w1) + dot(perp, v2) +\n  // dot(cross(r2, perp), v2)\n  // J = [-perp, -cross(d + r1, perp), perp, cross(r2,perp)]\n  //\n  // Angular constraint\n  // C = a2 - a1 + a_initial\n  // Cdot = w2 - w1\n  // J = [0 0 -1 0 0 1]\n  //\n  // K = J * invM * JT\n  //\n  // J = [-a -s1 a s2]\n  // [0 -1 0 1]\n  // a = perp\n  // s1 = cross(d + r1, a) = cross(p2 - x1, a)\n  // s2 = cross(r2, a) = cross(p2 - x2, a)\n\n  // Motor/Limit linear constraint\n  // C = dot(ax1, d)\n  // Cdot = = -dot(ax1, v1) - dot(cross(d + r1, ax1), w1) + dot(ax1, v2) +\n  // dot(cross(r2, ax1), v2)\n  // J = [-ax1 -cross(d+r1,ax1) ax1 cross(r2,ax1)]\n\n  // Block Solver\n  // We develop a block solver that includes the joint limit. This makes the\n  // limit stiff (inelastic) even\n  // when the mass has poor distribution (leading to large torques about the\n  // joint anchor points).\n  //\n  // The Jacobian has 3 rows:\n  // J = [-uT -s1 uT s2] // linear\n  // [0 -1 0 1] // angular\n  // [-vT -a1 vT a2] // limit\n  //\n  // u = perp\n  // v = axis\n  // s1 = cross(d + r1, u), s2 = cross(r2, u)\n  // a1 = cross(d + r1, v), a2 = cross(r2, v)\n\n  // M * (v2 - v1) = JT * df\n  // J * v2 = bias\n  //\n  // v2 = v1 + invM * JT * df\n  // J * (v1 + invM * JT * df) = bias\n  // K * df = bias - J * v1 = -Cdot\n  // K = J * invM * JT\n  // Cdot = J * v1 - bias\n  //\n  // Now solve for f2.\n  // df = f2 - f1\n  // K * (f2 - f1) = -Cdot\n  // f2 = invK * (-Cdot) + f1\n  //\n  // Clamp accumulated limit impulse.\n  // lower: f2(3) = max(f2(3), 0)\n  // upper: f2(3) = min(f2(3), 0)\n  //\n  // Solve for correct f2(1:2)\n  // K(1:2, 1:2) * f2(1:2) = -Cdot(1:2) - K(1:2,3) * f2(3) + K(1:2,1:3) * f1\n  // = -Cdot(1:2) - K(1:2,3) * f2(3) + K(1:2,1:2) * f1(1:2) + K(1:2,3) * f1(3)\n  // K(1:2, 1:2) * f2(1:2) = -Cdot(1:2) - K(1:2,3) * (f2(3) - f1(3)) +\n  // K(1:2,1:2) * f1(1:2)\n  // f2(1:2) = invK(1:2,1:2) * (-Cdot(1:2) - K(1:2,3) * (f2(3) - f1(3))) +\n  // f1(1:2)\n  //\n  // Now compute impulse to be applied:\n  // df = f2 - f1\n}\n\nPrismaticJoint.prototype._serialize = function() {\n  return {\n    type: this.m_type,\n    bodyA: this.m_bodyA,\n    bodyB: this.m_bodyB,\n    collideConnected: this.m_collideConnected,\n\n    lowerTranslation: this.m_lowerTranslation,\n    upperTranslation: this.m_upperTranslation,\n    maxMotorForce: this.m_maxMotorForce,\n    motorSpeed: this.m_motorSpeed,\n    enableLimit: this.m_enableLimit,\n    enableMotor: this.m_enableMotor,\n\n    localAnchorA: this.m_localAnchorA,\n    localAnchorB: this.m_localAnchorB,\n    localAxisA: this.m_localXAxisA,\n    referenceAngle: this.m_referenceAngle,\n  };\n};\n\nPrismaticJoint._deserialize = function(data, world, restore) {\n  data = Object.assign({}, data);\n  data.bodyA = restore(Body, data.bodyA, world);\n  data.bodyB = restore(Body, data.bodyB, world);\n  data.localAxisA = Vec2(data.localAxisA);\n  var joint = new PrismaticJoint(data);\n  return joint;\n};\n\n/**\n * @internal\n */\nPrismaticJoint.prototype._setAnchors = function(def) {\n  if (def.anchorA) {\n    this.m_localAnchorA.set(this.m_bodyA.getLocalPoint(def.anchorA));\n  } else if (def.localAnchorA) {\n    this.m_localAnchorA.set(def.localAnchorA);\n  }\n\n  if (def.anchorB) {\n    this.m_localAnchorB.set(this.m_bodyB.getLocalPoint(def.anchorB));\n  } else if (def.localAnchorB) {\n    this.m_localAnchorB.set(def.localAnchorB);\n  }\n\n  if (def.localAxisA) {\n    this.m_localXAxisA.set(def.localAxisA);\n    this.m_localYAxisA.set(Vec2.cross(1.0, def.localAxisA));\n  }\n}\n\n/**\n * The local anchor point relative to bodyA's origin.\n */\nPrismaticJoint.prototype.getLocalAnchorA = function() {\n  return this.m_localAnchorA;\n}\n\n/**\n * The local anchor point relative to bodyB's origin.\n */\nPrismaticJoint.prototype.getLocalAnchorB = function() {\n  return this.m_localAnchorB;\n}\n\n/**\n * The local joint axis relative to bodyA.\n */\nPrismaticJoint.prototype.getLocalAxisA = function() {\n  return this.m_localXAxisA;\n}\n\n/**\n * Get the reference angle.\n */\nPrismaticJoint.prototype.getReferenceAngle = function() {\n  return this.m_referenceAngle;\n}\n\n/**\n * Get the current joint translation, usually in meters.\n */\nPrismaticJoint.prototype.getJointTranslation = function() {\n  var pA = this.m_bodyA.getWorldPoint(this.m_localAnchorA);\n  var pB = this.m_bodyB.getWorldPoint(this.m_localAnchorB);\n  var d = Vec2.sub(pB, pA);\n  var axis = this.m_bodyA.getWorldVector(this.m_localXAxisA);\n\n  var translation = Vec2.dot(d, axis);\n  return translation;\n}\n\n/**\n * Get the current joint translation speed, usually in meters per second.\n */\nPrismaticJoint.prototype.getJointSpeed = function() {\n  var bA = this.m_bodyA;\n  var bB = this.m_bodyB;\n\n  var rA = Rot.mulVec2(bA.m_xf.q, Vec2.sub(this.m_localAnchorA, bA.m_sweep.localCenter)); // Vec2\n  var rB = Rot.mulVec2(bB.m_xf.q, Vec2.sub(this.m_localAnchorB, bB.m_sweep.localCenter)); // Vec2\n  var p1 = Vec2.add(bA.m_sweep.c, rA); // Vec2\n  var p2 = Vec2.add(bB.m_sweep.c, rB); // Vec2\n  var d = Vec2.sub(p2, p1); // Vec2\n  var axis = Rot.mulVec2(bA.m_xf.q, this.m_localXAxisA); // Vec2\n\n  var vA = bA.m_linearVelocity; // Vec2\n  var vB = bB.m_linearVelocity; // Vec2\n  var wA = bA.m_angularVelocity; // float\n  var wB = bB.m_angularVelocity; // float\n\n  var speed = Vec2.dot(d, Vec2.cross(wA, axis))\n      + Vec2.dot(axis, Vec2.sub(Vec2.addCross(vB, wB, rB), Vec2.addCross(vA, wA, rA))); // float\n  return speed;\n}\n\n/**\n * Is the joint limit enabled?\n */\nPrismaticJoint.prototype.isLimitEnabled = function() {\n  return this.m_enableLimit;\n}\n\n/**\n * Enable/disable the joint limit.\n */\nPrismaticJoint.prototype.enableLimit = function(flag) {\n  if (flag != this.m_enableLimit) {\n    this.m_bodyA.setAwake(true);\n    this.m_bodyB.setAwake(true);\n    this.m_enableLimit = flag;\n    this.m_impulse.z = 0.0;\n  }\n}\n\n/**\n * Get the lower joint limit, usually in meters.\n */\nPrismaticJoint.prototype.getLowerLimit = function() {\n  return this.m_lowerTranslation;\n}\n\n/**\n * Get the upper joint limit, usually in meters.\n */\nPrismaticJoint.prototype.getUpperLimit = function() {\n  return this.m_upperTranslation;\n}\n\n/**\n * Set the joint limits, usually in meters.\n */\nPrismaticJoint.prototype.setLimits = function(lower, upper) {\n  _ASSERT && common.assert(lower <= upper);\n  if (lower != this.m_lowerTranslation || upper != this.m_upperTranslation) {\n    this.m_bodyA.setAwake(true);\n    this.m_bodyB.setAwake(true);\n    this.m_lowerTranslation = lower;\n    this.m_upperTranslation = upper;\n    this.m_impulse.z = 0.0;\n  }\n}\n\n/**\n * Is the joint motor enabled?\n */\nPrismaticJoint.prototype.isMotorEnabled = function() {\n  return this.m_enableMotor;\n}\n\n/**\n * Enable/disable the joint motor.\n */\nPrismaticJoint.prototype.enableMotor = function(flag) {\n  this.m_bodyA.setAwake(true);\n  this.m_bodyB.setAwake(true);\n  this.m_enableMotor = flag;\n}\n\n/**\n * Set the motor speed, usually in meters per second.\n */\nPrismaticJoint.prototype.setMotorSpeed = function(speed) {\n  this.m_bodyA.setAwake(true);\n  this.m_bodyB.setAwake(true);\n  this.m_motorSpeed = speed;\n}\n\n/**\n * Set the maximum motor force, usually in N.\n */\nPrismaticJoint.prototype.setMaxMotorForce = function(force) {\n  this.m_bodyA.setAwake(true);\n  this.m_bodyB.setAwake(true);\n  this.m_maxMotorForce = force;\n}\n\nPrismaticJoint.prototype.getMaxMotorForce = function() {\n  return this.m_maxMotorForce;\n}\n\n/**\n * Get the motor speed, usually in meters per second.\n */\nPrismaticJoint.prototype.getMotorSpeed = function() {\n  return this.m_motorSpeed;\n}\n\n/**\n * Get the current motor force given the inverse time step, usually in N.\n */\nPrismaticJoint.prototype.getMotorForce = function(inv_dt) {\n  return inv_dt * this.m_motorImpulse;\n}\n\nPrismaticJoint.prototype.getAnchorA = function() {\n  return this.m_bodyA.getWorldPoint(this.m_localAnchorA);\n}\n\nPrismaticJoint.prototype.getAnchorB = function() {\n  return this.m_bodyB.getWorldPoint(this.m_localAnchorB);\n}\n\nPrismaticJoint.prototype.getReactionForce = function(inv_dt) {\n  return Vec2.combine(this.m_impulse.x, this.m_perp, this.m_motorImpulse + this.m_impulse.z, this.m_axis).mul(inv_dt);\n}\n\nPrismaticJoint.prototype.getReactionTorque = function(inv_dt) {\n  return inv_dt * this.m_impulse.y;\n}\n\nPrismaticJoint.prototype.initVelocityConstraints = function(step) {\n  this.m_localCenterA = this.m_bodyA.m_sweep.localCenter;\n  this.m_localCenterB = this.m_bodyB.m_sweep.localCenter;\n  this.m_invMassA = this.m_bodyA.m_invMass;\n  this.m_invMassB = this.m_bodyB.m_invMass;\n  this.m_invIA = this.m_bodyA.m_invI;\n  this.m_invIB = this.m_bodyB.m_invI;\n\n  var cA = this.m_bodyA.c_position.c;\n  var aA = this.m_bodyA.c_position.a;\n  var vA = this.m_bodyA.c_velocity.v;\n  var wA = this.m_bodyA.c_velocity.w;\n\n  var cB = this.m_bodyB.c_position.c;\n  var aB = this.m_bodyB.c_position.a;\n  var vB = this.m_bodyB.c_velocity.v;\n  var wB = this.m_bodyB.c_velocity.w;\n\n  var qA = Rot.neo(aA);\n  var qB = Rot.neo(aB);\n\n  // Compute the effective masses.\n  var rA = Rot.mulVec2(qA, Vec2.sub(this.m_localAnchorA, this.m_localCenterA));\n  var rB = Rot.mulVec2(qB, Vec2.sub(this.m_localAnchorB, this.m_localCenterB));\n  var d = Vec2.zero();\n  d.addCombine(1, cB, 1, rB);\n  d.subCombine(1, cA, 1, rA);\n\n  var mA = this.m_invMassA, mB = this.m_invMassB;\n  var iA = this.m_invIA, iB = this.m_invIB;\n\n  // Compute motor Jacobian and effective mass.\n  {\n    this.m_axis = Rot.mulVec2(qA, this.m_localXAxisA);\n    this.m_a1 = Vec2.cross(Vec2.add(d, rA), this.m_axis);\n    this.m_a2 = Vec2.cross(rB, this.m_axis);\n\n    this.m_motorMass = mA + mB + iA * this.m_a1 * this.m_a1 + iB * this.m_a2\n        * this.m_a2;\n    if (this.m_motorMass > 0.0) {\n      this.m_motorMass = 1.0 / this.m_motorMass;\n    }\n  }\n\n  // Prismatic constraint.\n  {\n    this.m_perp = Rot.mulVec2(qA, this.m_localYAxisA);\n\n    this.m_s1 = Vec2.cross(Vec2.add(d, rA), this.m_perp);\n    this.m_s2 = Vec2.cross(rB, this.m_perp);\n\n    var s1test = Vec2.cross(rA, this.m_perp);\n\n    var k11 = mA + mB + iA * this.m_s1 * this.m_s1 + iB * this.m_s2 * this.m_s2;\n    var k12 = iA * this.m_s1 + iB * this.m_s2;\n    var k13 = iA * this.m_s1 * this.m_a1 + iB * this.m_s2 * this.m_a2;\n    var k22 = iA + iB;\n    if (k22 == 0.0) {\n      // For bodies with fixed rotation.\n      k22 = 1.0;\n    }\n    var k23 = iA * this.m_a1 + iB * this.m_a2;\n    var k33 = mA + mB + iA * this.m_a1 * this.m_a1 + iB * this.m_a2 * this.m_a2;\n\n    this.m_K.ex.set(k11, k12, k13);\n    this.m_K.ey.set(k12, k22, k23);\n    this.m_K.ez.set(k13, k23, k33);\n  }\n\n  // Compute motor and limit terms.\n  if (this.m_enableLimit) {\n\n    var jointTranslation = Vec2.dot(this.m_axis, d); // float\n    if (Math.abs(this.m_upperTranslation - this.m_lowerTranslation) < 2.0 * Settings.linearSlop) {\n      this.m_limitState = equalLimits;\n\n    } else if (jointTranslation <= this.m_lowerTranslation) {\n      if (this.m_limitState != atLowerLimit) {\n        this.m_limitState = atLowerLimit;\n        this.m_impulse.z = 0.0;\n      }\n\n    } else if (jointTranslation >= this.m_upperTranslation) {\n      if (this.m_limitState != atUpperLimit) {\n        this.m_limitState = atUpperLimit;\n        this.m_impulse.z = 0.0;\n      }\n\n    } else {\n      this.m_limitState = inactiveLimit;\n      this.m_impulse.z = 0.0;\n    }\n\n  } else {\n    this.m_limitState = inactiveLimit;\n    this.m_impulse.z = 0.0;\n  }\n\n  if (this.m_enableMotor == false) {\n    this.m_motorImpulse = 0.0;\n  }\n\n  if (step.warmStarting) {\n    // Account for variable time step.\n    this.m_impulse.mul(step.dtRatio);\n    this.m_motorImpulse *= step.dtRatio;\n\n    var P = Vec2.combine(this.m_impulse.x, this.m_perp, this.m_motorImpulse\n        + this.m_impulse.z, this.m_axis);\n    var LA = this.m_impulse.x * this.m_s1 + this.m_impulse.y\n        + (this.m_motorImpulse + this.m_impulse.z) * this.m_a1;\n    var LB = this.m_impulse.x * this.m_s2 + this.m_impulse.y\n        + (this.m_motorImpulse + this.m_impulse.z) * this.m_a2;\n\n    vA.subMul(mA, P);\n    wA -= iA * LA;\n\n    vB.addMul(mB, P);\n    wB += iB * LB;\n  } else {\n    this.m_impulse.setZero();\n    this.m_motorImpulse = 0.0;\n  }\n\n  this.m_bodyA.c_velocity.v.set(vA);\n  this.m_bodyA.c_velocity.w = wA;\n  this.m_bodyB.c_velocity.v.set(vB);\n  this.m_bodyB.c_velocity.w = wB;\n}\n\nPrismaticJoint.prototype.solveVelocityConstraints = function(step) {\n  var vA = this.m_bodyA.c_velocity.v;\n  var wA = this.m_bodyA.c_velocity.w;\n  var vB = this.m_bodyB.c_velocity.v;\n  var wB = this.m_bodyB.c_velocity.w;\n\n  var mA = this.m_invMassA;\n  var mB = this.m_invMassB;\n  var iA = this.m_invIA;\n  var iB = this.m_invIB;\n\n  // Solve linear motor constraint.\n  if (this.m_enableMotor && this.m_limitState != equalLimits) {\n    var Cdot = Vec2.dot(this.m_axis, Vec2.sub(vB, vA)) + this.m_a2 * wB\n        - this.m_a1 * wA;\n    var impulse = this.m_motorMass * (this.m_motorSpeed - Cdot);\n    var oldImpulse = this.m_motorImpulse;\n    var maxImpulse = step.dt * this.m_maxMotorForce;\n    this.m_motorImpulse = Math.clamp(this.m_motorImpulse + impulse,\n        -maxImpulse, maxImpulse);\n    impulse = this.m_motorImpulse - oldImpulse;\n\n    var P = Vec2.mul(impulse, this.m_axis);\n    var LA = impulse * this.m_a1;\n    var LB = impulse * this.m_a2;\n\n    vA.subMul(mA, P);\n    wA -= iA * LA;\n\n    vB.addMul(mB, P);\n    wB += iB * LB;\n  }\n\n  var Cdot1 = Vec2.zero();\n  Cdot1.x += Vec2.dot(this.m_perp, vB) + this.m_s2 * wB;\n  Cdot1.x -= Vec2.dot(this.m_perp, vA) + this.m_s1 * wA;\n  Cdot1.y = wB - wA;\n\n  if (this.m_enableLimit && this.m_limitState != inactiveLimit) {\n    // Solve prismatic and limit constraint in block form.\n    var Cdot2 = 0;\n    Cdot2 += Vec2.dot(this.m_axis, vB) + this.m_a2 * wB;\n    Cdot2 -= Vec2.dot(this.m_axis, vA) + this.m_a1 * wA;\n\n    var Cdot = Vec3(Cdot1.x, Cdot1.y, Cdot2);\n\n    var f1 = Vec3(this.m_impulse);\n    var df = this.m_K.solve33(Vec3.neg(Cdot)); // Vec3\n    this.m_impulse.add(df);\n\n    if (this.m_limitState == atLowerLimit) {\n      this.m_impulse.z = Math.max(this.m_impulse.z, 0.0);\n    } else if (this.m_limitState == atUpperLimit) {\n      this.m_impulse.z = Math.min(this.m_impulse.z, 0.0);\n    }\n\n    // f2(1:2) = invK(1:2,1:2) * (-Cdot(1:2) - K(1:2,3) * (f2(3) - f1(3))) +\n    // f1(1:2)\n    var b = Vec2.combine(-1, Cdot1, -(this.m_impulse.z - f1.z), Vec2.neo(this.m_K.ez.x, this.m_K.ez.y)); // Vec2\n    var f2r = Vec2.add(this.m_K.solve22(b), Vec2.neo(f1.x, f1.y)); // Vec2\n    this.m_impulse.x = f2r.x;\n    this.m_impulse.y = f2r.y;\n\n    df = Vec3.sub(this.m_impulse, f1);\n\n    var P = Vec2.combine(df.x, this.m_perp, df.z, this.m_axis); // Vec2\n    var LA = df.x * this.m_s1 + df.y + df.z * this.m_a1; // float\n    var LB = df.x * this.m_s2 + df.y + df.z * this.m_a2; // float\n\n    vA.subMul(mA, P);\n    wA -= iA * LA;\n\n    vB.addMul(mB, P);\n    wB += iB * LB;\n  } else {\n    // Limit is inactive, just solve the prismatic constraint in block form.\n    var df = this.m_K.solve22(Vec2.neg(Cdot1)); // Vec2\n    this.m_impulse.x += df.x;\n    this.m_impulse.y += df.y;\n\n    var P = Vec2.mul(df.x, this.m_perp); // Vec2\n    var LA = df.x * this.m_s1 + df.y; // float\n    var LB = df.x * this.m_s2 + df.y; // float\n\n    vA.subMul(mA, P);\n    wA -= iA * LA;\n\n    vB.addMul(mB, P);\n    wB += iB * LB;\n  }\n\n  this.m_bodyA.c_velocity.v = vA;\n  this.m_bodyA.c_velocity.w = wA;\n  this.m_bodyB.c_velocity.v = vB;\n  this.m_bodyB.c_velocity.w = wB;\n}\n\nPrismaticJoint.prototype.solvePositionConstraints = function(step) {\n  var cA = this.m_bodyA.c_position.c;\n  var aA = this.m_bodyA.c_position.a;\n  var cB = this.m_bodyB.c_position.c;\n  var aB = this.m_bodyB.c_position.a;\n\n  var qA = Rot.neo(aA);\n  var qB = Rot.neo(aB);\n\n  var mA = this.m_invMassA;\n  var mB = this.m_invMassB;\n  var iA = this.m_invIA;\n  var iB = this.m_invIB;\n\n  // Compute fresh Jacobians\n  var rA = Rot.mulVec2(qA, Vec2.sub(this.m_localAnchorA, this.m_localCenterA)); // Vec2\n  var rB = Rot.mulVec2(qB, Vec2.sub(this.m_localAnchorB, this.m_localCenterB)); // Vec2\n  var d = Vec2.sub(Vec2.add(cB, rB), Vec2.add(cA, rA)); // Vec2\n\n  var axis = Rot.mulVec2(qA, this.m_localXAxisA); // Vec2\n  var a1 = Vec2.cross(Vec2.add(d, rA), axis); // float\n  var a2 = Vec2.cross(rB, axis); // float\n  var perp = Rot.mulVec2(qA, this.m_localYAxisA); // Vec2\n\n  var s1 = Vec2.cross(Vec2.add(d, rA), perp); // float\n  var s2 = Vec2.cross(rB, perp); // float\n\n  var impulse = Vec3();\n  var C1 = Vec2.zero(); // Vec2\n  C1.x = Vec2.dot(perp, d);\n  C1.y = aB - aA - this.m_referenceAngle;\n\n  var linearError = Math.abs(C1.x); // float\n  var angularError = Math.abs(C1.y); // float\n\n  var linearSlop = Settings.linearSlop;\n  var maxLinearCorrection = Settings.maxLinearCorrection;\n\n  var active = false; // bool\n  var C2 = 0.0; // float\n  if (this.m_enableLimit) {\n\n    var translation = Vec2.dot(axis, d); // float\n    if (Math.abs(this.m_upperTranslation - this.m_lowerTranslation) < 2.0 * linearSlop) {\n      // Prevent large angular corrections\n      C2 = Math.clamp(translation, -maxLinearCorrection, maxLinearCorrection);\n      linearError = Math.max(linearError, Math.abs(translation));\n      active = true;\n\n    } else if (translation <= this.m_lowerTranslation) {\n      // Prevent large linear corrections and allow some slop.\n      C2 = Math.clamp(translation - this.m_lowerTranslation + linearSlop,\n          -maxLinearCorrection, 0.0);\n      linearError = Math\n          .max(linearError, this.m_lowerTranslation - translation);\n      active = true;\n\n    } else if (translation >= this.m_upperTranslation) {\n      // Prevent large linear corrections and allow some slop.\n      C2 = Math.clamp(translation - this.m_upperTranslation - linearSlop, 0.0,\n          maxLinearCorrection);\n      linearError = Math\n          .max(linearError, translation - this.m_upperTranslation);\n      active = true;\n    }\n  }\n\n  if (active) {\n    var k11 = mA + mB + iA * s1 * s1 + iB * s2 * s2; // float\n    var k12 = iA * s1 + iB * s2; // float\n    var k13 = iA * s1 * a1 + iB * s2 * a2; // float\n    var k22 = iA + iB; // float\n    if (k22 == 0.0) {\n      // For fixed rotation\n      k22 = 1.0;\n    }\n    var k23 = iA * a1 + iB * a2; // float\n    var k33 = mA + mB + iA * a1 * a1 + iB * a2 * a2; // float\n\n    var K = new Mat33()\n    K.ex.set(k11, k12, k13);\n    K.ey.set(k12, k22, k23);\n    K.ez.set(k13, k23, k33);\n\n    var C = Vec3();\n    C.x = C1.x;\n    C.y = C1.y;\n    C.z = C2;\n\n    impulse = K.solve33(Vec3.neg(C));\n  } else {\n    var k11 = mA + mB + iA * s1 * s1 + iB * s2 * s2; // float\n    var k12 = iA * s1 + iB * s2; // float\n    var k22 = iA + iB; // float\n    if (k22 == 0.0) {\n      k22 = 1.0;\n    }\n\n    var K = new Mat22();\n    K.ex.set(k11, k12);\n    K.ey.set(k12, k22);\n\n    var impulse1 = K.solve(Vec2.neg(C1)); // Vec2\n    impulse.x = impulse1.x;\n    impulse.y = impulse1.y;\n    impulse.z = 0.0;\n  }\n\n  var P = Vec2.combine(impulse.x, perp, impulse.z, axis); // Vec2\n  var LA = impulse.x * s1 + impulse.y + impulse.z * a1; // float\n  var LB = impulse.x * s2 + impulse.y + impulse.z * a2; // float\n\n  cA.subMul(mA, P);\n  aA -= iA * LA;\n  cB.addMul(mB, P);\n  aB += iB * LB;\n\n  this.m_bodyA.c_position.c = cA;\n  this.m_bodyA.c_position.a = aA;\n  this.m_bodyB.c_position.c = cB;\n  this.m_bodyB.c_position.a = aB;\n\n  return linearError <= Settings.linearSlop\n      && angularError <= Settings.angularSlop;\n}\n","/*\n * Planck.js\n * The MIT License\n * Copyright (c) 2021 Erin Catto, Ali Shakiba\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 all\n * 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 THE\n * SOFTWARE.\n */\n\nvar _DEBUG = typeof DEBUG === 'undefined' ? false : DEBUG;\nvar _ASSERT = typeof ASSERT === 'undefined' ? false : ASSERT;\n\nmodule.exports = PulleyJoint;\n\nvar common = require('../util/common');\nvar options = require('../util/options');\nvar Settings = require('../Settings');\n\nvar Math = require('../common/Math');\nvar Vec2 = require('../common/Vec2');\nvar Vec3 = require('../common/Vec3');\nvar Mat22 = require('../common/Mat22');\nvar Mat33 = require('../common/Mat33');\nvar Rot = require('../common/Rot');\nvar Sweep = require('../common/Sweep');\nvar Transform = require('../common/Transform');\nvar Velocity = require('../common/Velocity');\nvar Position = require('../common/Position');\n\nvar Joint = require('../Joint');\nvar Body = require('../Body');\n\nPulleyJoint.TYPE = 'pulley-joint';\nPulleyJoint.MIN_PULLEY_LENGTH = 2.0; // minPulleyLength\nJoint.TYPES[PulleyJoint.TYPE] = PulleyJoint;\n\nPulleyJoint._super = Joint;\nPulleyJoint.prototype = Object.create(PulleyJoint._super.prototype);\n\n/**\n * @typedef {Object} PulleyJointDef\n *\n * Pulley joint definition. This requires two ground anchors, two dynamic body\n * anchor points, and a pulley ratio.\n *\n * @prop {Vec2} groundAnchorA The first ground anchor in world coordinates.\n *          This point never moves.\n * @prop {Vec2} groundAnchorB The second ground anchor in world coordinates.\n *          This point never moves.\n * @prop {Vec2} localAnchorA The local anchor point relative to bodyA's origin.\n * @prop {Vec2} localAnchorB The local anchor point relative to bodyB's origin.\n * @prop {float} ratio The pulley ratio, used to simulate a block-and-tackle.\n * @prop {float} lengthA The reference length for the segment attached to bodyA.\n * @prop {float} lengthB The reference length for the segment attached to bodyB.\n */\nvar PulleyJointDef = {\n  collideConnected : true\n};\n\n/**\n * The pulley joint is connected to two bodies and two fixed ground points. The\n * pulley supports a ratio such that: length1 + ratio * length2 <= constant\n * \n * Yes, the force transmitted is scaled by the ratio.\n * \n * Warning: the pulley joint can get a bit squirrelly by itself. They often work\n * better when combined with prismatic joints. You should also cover the the\n * anchor points with static shapes to prevent one side from going to zero\n * length.\n *\n * @param {PulleyJointDef} def\n * @param {Body} bodyA\n * @param {Body} bodyB\n */\nfunction PulleyJoint(def, bodyA, bodyB, groundA, groundB, anchorA, anchorB, ratio) {\n  if (!(this instanceof PulleyJoint)) {\n    return new PulleyJoint(def, bodyA, bodyB, groundA, groundB, anchorA, anchorB, ratio);\n  }\n\n  def = options(def, PulleyJointDef);\n  Joint.call(this, def, bodyA, bodyB);\n  bodyA = this.m_bodyA;\n  bodyB = this.m_bodyB;\n\n  this.m_type = PulleyJoint.TYPE;\n  this.m_groundAnchorA = groundA ? groundA : def.groundAnchorA || Vec2.neo(-1.0, 1.0);\n  this.m_groundAnchorB = groundB ? groundB : def.groundAnchorB || Vec2.neo(1.0, 1.0);\n  this.m_localAnchorA = anchorA ? bodyA.getLocalPoint(anchorA) : def.localAnchorA || Vec2.neo(-1.0, 0.0);\n  this.m_localAnchorB = anchorB ? bodyB.getLocalPoint(anchorB) : def.localAnchorB || Vec2.neo(1.0, 0.0);\n  this.m_lengthA = Math.isFinite(def.lengthA) ? def.lengthA : Vec2.distance(anchorA, groundA);\n  this.m_lengthB = Math.isFinite(def.lengthB) ? def.lengthB : Vec2.distance(anchorB, groundB);\n  this.m_ratio = Math.isFinite(ratio) ? ratio : def.ratio;\n\n  _ASSERT && common.assert(ratio > Math.EPSILON);\n\n  this.m_constant = this.m_lengthA + this.m_ratio * this.m_lengthB;\n\n  this.m_impulse = 0.0;\n\n  // Solver temp\n  this.m_uA; // Vec2\n  this.m_uB; // Vec2\n  this.m_rA; // Vec2\n  this.m_rB; // Vec2\n  this.m_localCenterA; // Vec2\n  this.m_localCenterB; // Vec2\n  this.m_invMassA; // float\n  this.m_invMassB; // float\n  this.m_invIA; // float\n  this.m_invIB; // float\n  this.m_mass; // float\n\n  // Pulley:\n  // length1 = norm(p1 - s1)\n  // length2 = norm(p2 - s2)\n  // C0 = (length1 + ratio * length2)_initial\n  // C = C0 - (length1 + ratio * length2)\n  // u1 = (p1 - s1) / norm(p1 - s1)\n  // u2 = (p2 - s2) / norm(p2 - s2)\n  // Cdot = -dot(u1, v1 + cross(w1, r1)) - ratio * dot(u2, v2 + cross(w2, r2))\n  // J = -[u1 cross(r1, u1) ratio * u2 ratio * cross(r2, u2)]\n  // K = J * invM * JT\n  // = invMass1 + invI1 * cross(r1, u1)^2 + ratio^2 * (invMass2 + invI2 *\n  // cross(r2, u2)^2)\n}\n\nPulleyJoint.prototype._serialize = function() {\n  return {\n    type: this.m_type,\n    bodyA: this.m_bodyA,\n    bodyB: this.m_bodyB,\n    collideConnected: this.m_collideConnected,\n\n    groundAnchorA: this.m_groundAnchorA,\n    groundAnchorB: this.m_groundAnchorB,\n    localAnchorA: this.m_localAnchorA,\n    localAnchorB: this.m_localAnchorB,\n    lengthA: this.m_lengthA,\n    lengthB: this.m_lengthB,\n    ratio: this.m_ratio,\n  };\n};\n\nPulleyJoint._deserialize = function(data, world, restore) {\n  data = Object.assign({}, data);\n  data.bodyA = restore(Body, data.bodyA, world);\n  data.bodyB = restore(Body, data.bodyB, world);\n  var joint = new PulleyJoint(data);\n  return joint;\n};\n\n/**\n * Get the first ground anchor.\n */\nPulleyJoint.prototype.getGroundAnchorA = function() {\n  return this.m_groundAnchorA;\n}\n\n/**\n * Get the second ground anchor.\n */\nPulleyJoint.prototype.getGroundAnchorB = function() {\n  return this.m_groundAnchorB;\n}\n\n/**\n * Get the current length of the segment attached to bodyA.\n */\nPulleyJoint.prototype.getLengthA = function() {\n  return this.m_lengthA;\n}\n\n/**\n * Get the current length of the segment attached to bodyB.\n */\nPulleyJoint.prototype.getLengthB = function() {\n  return this.m_lengthB;\n}\n\n/**\n * Get the pulley ratio.\n */\nPulleyJoint.prototype.getRatio = function() {\n  return this.m_ratio;\n}\n\n/**\n * Get the current length of the segment attached to bodyA.\n */\nPulleyJoint.prototype.getCurrentLengthA = function() {\n  var p = this.m_bodyA.getWorldPoint(this.m_localAnchorA);\n  var s = this.m_groundAnchorA;\n  return Vec2.distance(p, s);\n}\n\n/**\n * Get the current length of the segment attached to bodyB.\n */\nPulleyJoint.prototype.getCurrentLengthB = function() {\n  var p = this.m_bodyB.getWorldPoint(this.m_localAnchorB);\n  var s = this.m_groundAnchorB;\n  return Vec2.distance(p, s);\n}\n\nPulleyJoint.prototype.shiftOrigin = function(newOrigin) {\n  this.m_groundAnchorA.sub(newOrigin);\n  this.m_groundAnchorB.sub(newOrigin);\n}\n\nPulleyJoint.prototype.getAnchorA = function() {\n  return this.m_bodyA.getWorldPoint(this.m_localAnchorA);\n}\n\nPulleyJoint.prototype.getAnchorB = function() {\n  return this.m_bodyB.getWorldPoint(this.m_localAnchorB);\n}\n\nPulleyJoint.prototype.getReactionForce = function(inv_dt) {\n  return Vec2.mul(this.m_impulse, this.m_uB).mul(inv_dt);\n}\n\nPulleyJoint.prototype.getReactionTorque = function(inv_dt) {\n  return 0.0;\n}\n\nPulleyJoint.prototype.initVelocityConstraints = function(step) {\n  this.m_localCenterA = this.m_bodyA.m_sweep.localCenter;\n  this.m_localCenterB = this.m_bodyB.m_sweep.localCenter;\n  this.m_invMassA = this.m_bodyA.m_invMass;\n  this.m_invMassB = this.m_bodyB.m_invMass;\n  this.m_invIA = this.m_bodyA.m_invI;\n  this.m_invIB = this.m_bodyB.m_invI;\n\n  var cA = this.m_bodyA.c_position.c;\n  var aA = this.m_bodyA.c_position.a;\n  var vA = this.m_bodyA.c_velocity.v;\n  var wA = this.m_bodyA.c_velocity.w;\n\n  var cB = this.m_bodyB.c_position.c;\n  var aB = this.m_bodyB.c_position.a;\n  var vB = this.m_bodyB.c_velocity.v;\n  var wB = this.m_bodyB.c_velocity.w;\n\n  var qA = Rot.neo(aA);\n  var qB = Rot.neo(aB);\n\n  this.m_rA = Rot.mulVec2(qA, Vec2.sub(this.m_localAnchorA, this.m_localCenterA));\n  this.m_rB = Rot.mulVec2(qB, Vec2.sub(this.m_localAnchorB, this.m_localCenterB));\n\n  // Get the pulley axes.\n  this.m_uA = Vec2.sub(Vec2.add(cA, this.m_rA), this.m_groundAnchorA);\n  this.m_uB = Vec2.sub(Vec2.add(cB, this.m_rB), this.m_groundAnchorB);\n\n  var lengthA = this.m_uA.length();\n  var lengthB = this.m_uB.length();\n\n  if (lengthA > 10.0 * Settings.linearSlop) {\n    this.m_uA.mul(1.0 / lengthA);\n  } else {\n    this.m_uA.setZero();\n  }\n\n  if (lengthB > 10.0 * Settings.linearSlop) {\n    this.m_uB.mul(1.0 / lengthB);\n  } else {\n    this.m_uB.setZero();\n  }\n\n  // Compute effective mass.\n  var ruA = Vec2.cross(this.m_rA, this.m_uA); // float\n  var ruB = Vec2.cross(this.m_rB, this.m_uB); // float\n\n  var mA = this.m_invMassA + this.m_invIA * ruA * ruA; // float\n  var mB = this.m_invMassB + this.m_invIB * ruB * ruB; // float\n\n  this.m_mass = mA + this.m_ratio * this.m_ratio * mB;\n\n  if (this.m_mass > 0.0) {\n    this.m_mass = 1.0 / this.m_mass;\n  }\n\n  if (step.warmStarting) {\n    // Scale impulses to support variable time steps.\n    this.m_impulse *= step.dtRatio;\n\n    // Warm starting.\n    var PA = Vec2.mul(-this.m_impulse, this.m_uA);\n    var PB = Vec2.mul(-this.m_ratio * this.m_impulse, this.m_uB);\n\n    vA.addMul(this.m_invMassA, PA);\n    wA += this.m_invIA * Vec2.cross(this.m_rA, PA);\n\n    vB.addMul(this.m_invMassB, PB);\n    wB += this.m_invIB * Vec2.cross(this.m_rB, PB);\n\n  } else {\n    this.m_impulse = 0.0;\n  }\n\n  this.m_bodyA.c_velocity.v = vA;\n  this.m_bodyA.c_velocity.w = wA;\n  this.m_bodyB.c_velocity.v = vB;\n  this.m_bodyB.c_velocity.w = wB;\n}\n\nPulleyJoint.prototype.solveVelocityConstraints = function(step) {\n  var vA = this.m_bodyA.c_velocity.v;\n  var wA = this.m_bodyA.c_velocity.w;\n  var vB = this.m_bodyB.c_velocity.v;\n  var wB = this.m_bodyB.c_velocity.w;\n\n  var vpA = Vec2.add(vA, Vec2.cross(wA, this.m_rA));\n  var vpB = Vec2.add(vB, Vec2.cross(wB, this.m_rB));\n\n  var Cdot = -Vec2.dot(this.m_uA, vpA) - this.m_ratio\n      * Vec2.dot(this.m_uB, vpB); // float\n  var impulse = -this.m_mass * Cdot; // float\n  this.m_impulse += impulse;\n\n  var PA = Vec2.mul(-impulse, this.m_uA); // Vec2\n  var PB = Vec2.mul(-this.m_ratio * impulse, this.m_uB); // Vec2\n  vA.addMul(this.m_invMassA, PA);\n  wA += this.m_invIA * Vec2.cross(this.m_rA, PA);\n  vB.addMul(this.m_invMassB, PB);\n  wB += this.m_invIB * Vec2.cross(this.m_rB, PB);\n\n  this.m_bodyA.c_velocity.v = vA;\n  this.m_bodyA.c_velocity.w = wA;\n  this.m_bodyB.c_velocity.v = vB;\n  this.m_bodyB.c_velocity.w = wB;\n}\n\nPulleyJoint.prototype.solvePositionConstraints = function(step) {\n  var cA = this.m_bodyA.c_position.c;\n  var aA = this.m_bodyA.c_position.a;\n  var cB = this.m_bodyB.c_position.c;\n  var aB = this.m_bodyB.c_position.a;\n\n  var qA = Rot.neo(aA), qB = Rot.neo(aB);\n\n  var rA = Rot.mulVec2(qA, Vec2.sub(this.m_localAnchorA, this.m_localCenterA));\n  var rB = Rot.mulVec2(qB, Vec2.sub(this.m_localAnchorB, this.m_localCenterB));\n\n  // Get the pulley axes.\n  var uA = Vec2.sub(Vec2.add(cA, this.m_rA), this.m_groundAnchorA);\n  var uB = Vec2.sub(Vec2.add(cB, this.m_rB), this.m_groundAnchorB);\n\n  var lengthA = uA.length();\n  var lengthB = uB.length();\n\n  if (lengthA > 10.0 * Settings.linearSlop) {\n    uA.mul(1.0 / lengthA);\n  } else {\n    uA.setZero();\n  }\n\n  if (lengthB > 10.0 * Settings.linearSlop) {\n    uB.mul(1.0 / lengthB);\n  } else {\n    uB.setZero();\n  }\n\n  // Compute effective mass.\n  var ruA = Vec2.cross(rA, uA);\n  var ruB = Vec2.cross(rB, uB);\n\n  var mA = this.m_invMassA + this.m_invIA * ruA * ruA; // float\n  var mB = this.m_invMassB + this.m_invIB * ruB * ruB; // float\n\n  var mass = mA + this.m_ratio * this.m_ratio * mB; // float\n\n  if (mass > 0.0) {\n    mass = 1.0 / mass;\n  }\n\n  var C = this.m_constant - lengthA - this.m_ratio * lengthB; // float\n  var linearError = Math.abs(C); // float\n\n  var impulse = -mass * C; // float\n\n  var PA = Vec2.mul(-impulse, uA); // Vec2\n  var PB = Vec2.mul(-this.m_ratio * impulse, uB); // Vec2\n\n  cA.addMul(this.m_invMassA, PA);\n  aA += this.m_invIA * Vec2.cross(rA, PA);\n  cB.addMul(this.m_invMassB, PB);\n  aB += this.m_invIB * Vec2.cross(rB, PB);\n\n  this.m_bodyA.c_position.c = cA;\n  this.m_bodyA.c_position.a = aA;\n  this.m_bodyB.c_position.c = cB;\n  this.m_bodyB.c_position.a = aB;\n\n  return linearError < Settings.linearSlop;\n}\n","/*\n * Planck.js\n * The MIT License\n * Copyright (c) 2021 Erin Catto, Ali Shakiba\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 all\n * 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 THE\n * SOFTWARE.\n */\n\nvar _DEBUG = typeof DEBUG === 'undefined' ? false : DEBUG;\nvar _ASSERT = typeof ASSERT === 'undefined' ? false : ASSERT;\n\nmodule.exports = RevoluteJoint;\n\nvar common = require('../util/common');\nvar options = require('../util/options');\nvar Settings = require('../Settings');\n\nvar Math = require('../common/Math');\nvar Vec2 = require('../common/Vec2');\nvar Vec3 = require('../common/Vec3');\nvar Mat22 = require('../common/Mat22');\nvar Mat33 = require('../common/Mat33');\nvar Rot = require('../common/Rot');\nvar Sweep = require('../common/Sweep');\nvar Transform = require('../common/Transform');\nvar Velocity = require('../common/Velocity');\nvar Position = require('../common/Position');\n\nvar Joint = require('../Joint');\nvar Body = require('../Body');\n\nvar inactiveLimit = 0;\nvar atLowerLimit = 1;\nvar atUpperLimit = 2;\nvar equalLimits = 3;\n\nRevoluteJoint.TYPE = 'revolute-joint';\nJoint.TYPES[RevoluteJoint.TYPE] = RevoluteJoint;\n\nRevoluteJoint._super = Joint;\nRevoluteJoint.prototype = Object.create(RevoluteJoint._super.prototype);\n\n/**\n * @typedef {Object} RevoluteJointDef\n *\n * Revolute joint definition. This requires defining an anchor point where the\n * bodies are joined. The definition uses local anchor points so that the\n * initial configuration can violate the constraint slightly. You also need to\n * specify the initial relative angle for joint limits. This helps when saving\n * and loading a game.\n *\n * The local anchor points are measured from the body's origin rather than the\n * center of mass because: 1. you might not know where the center of mass will\n * be. 2. if you add/remove shapes from a body and recompute the mass, the\n * joints will be broken.\n *\n * @prop {bool} enableLimit A flag to enable joint limits.\n * @prop {bool} enableMotor A flag to enable the joint motor.\n * @prop {float} lowerAngle The lower angle for the joint limit (radians).\n * @prop {float} upperAngle The upper angle for the joint limit (radians).\n * @prop {float} motorSpeed The desired motor speed. Usually in radians per\n *       second.\n * @prop {float} maxMotorTorque The maximum motor torque used to achieve the\n *       desired motor speed. Usually in N-m.\n *\n * @prop {Vec2} localAnchorA The local anchor point relative to bodyA's origin.\n * @prop {Vec2} localAnchorB The local anchor point relative to bodyB's origin.\n * @prop {float} referenceAngle The bodyB angle minus bodyA angle in the\n *       reference state (radians).\n */\n\nvar DEFAULTS = {\n  lowerAngle : 0.0,\n  upperAngle : 0.0,\n  maxMotorTorque : 0.0,\n  motorSpeed : 0.0,\n  enableLimit : false,\n  enableMotor : false\n};\n\n/**\n * A revolute joint constrains two bodies to share a common point while they are\n * free to rotate about the point. The relative rotation about the shared point\n * is the joint angle. You can limit the relative rotation with a joint limit\n * that specifies a lower and upper angle. You can use a motor to drive the\n * relative rotation about the shared point. A maximum motor torque is provided\n * so that infinite forces are not generated.\n *\n * @param {RevoluteJointDef} def\n * @param {Body} bodyA\n * @param {Body} bodyB\n */\nfunction RevoluteJoint(def, bodyA, bodyB, anchor) {\n  if (!(this instanceof RevoluteJoint)) {\n    return new RevoluteJoint(def, bodyA, bodyB, anchor);\n  }\n\n  def = options(def, DEFAULTS);\n  Joint.call(this, def, bodyA, bodyB);\n  bodyA = this.m_bodyA;\n  bodyB = this.m_bodyB;\n\n  this.m_type = RevoluteJoint.TYPE;\n\n  this.m_localAnchorA =  Vec2.clone(anchor ? bodyA.getLocalPoint(anchor) : def.localAnchorA || Vec2.zero());\n  this.m_localAnchorB =  Vec2.clone(anchor ? bodyB.getLocalPoint(anchor) : def.localAnchorB || Vec2.zero());\n  this.m_referenceAngle = Math.isFinite(def.referenceAngle) ? def.referenceAngle : bodyB.getAngle() - bodyA.getAngle();\n\n  this.m_impulse = Vec3();\n  this.m_motorImpulse = 0.0;\n\n  this.m_lowerAngle = def.lowerAngle;\n  this.m_upperAngle = def.upperAngle;\n  this.m_maxMotorTorque = def.maxMotorTorque;\n  this.m_motorSpeed = def.motorSpeed;\n  this.m_enableLimit = def.enableLimit;\n  this.m_enableMotor = def.enableMotor;\n\n  // Solver temp\n  this.m_rA; // Vec2\n  this.m_rB; // Vec2\n  this.m_localCenterA; // Vec2\n  this.m_localCenterB; // Vec2\n  this.m_invMassA; // float\n  this.m_invMassB; // float\n  this.m_invIA; // float\n  this.m_invIB; // float\n  // effective mass for point-to-point constraint.\n  this.m_mass = new Mat33();\n  // effective mass for motor/limit angular constraint.\n  this.m_motorMass; // float\n  this.m_limitState = inactiveLimit;\n\n  // Point-to-point constraint\n  // C = p2 - p1\n  // Cdot = v2 - v1\n  // = v2 + cross(w2, r2) - v1 - cross(w1, r1)\n  // J = [-I -r1_skew I r2_skew ]\n  // Identity used:\n  // w k % (rx i + ry j) = w * (-ry i + rx j)\n\n  // Motor constraint\n  // Cdot = w2 - w1\n  // J = [0 0 -1 0 0 1]\n  // K = invI1 + invI2\n}\n\nRevoluteJoint.prototype._serialize = function() {\n  return {\n    type: this.m_type,\n    bodyA: this.m_bodyA,\n    bodyB: this.m_bodyB,\n    collideConnected: this.m_collideConnected,\n\n    lowerAngle: this.m_lowerAngle,\n    upperAngle: this.m_upperAngle,\n    maxMotorTorque: this.m_maxMotorTorque,\n    motorSpeed: this.m_motorSpeed,\n    enableLimit: this.m_enableLimit,\n    enableMotor: this.m_enableMotor,\n\n    localAnchorA: this.m_localAnchorA,\n    localAnchorB: this.m_localAnchorB,\n    referenceAngle: this.m_referenceAngle,\n  };\n};\n\nRevoluteJoint._deserialize = function(data, world, restore) {\n  data = Object.assign({}, data);\n  data.bodyA = restore(Body, data.bodyA, world);\n  data.bodyB = restore(Body, data.bodyB, world);\n  var joint = new RevoluteJoint(data);\n  return joint;\n};\n\n/**\n * @internal\n */\nRevoluteJoint.prototype._setAnchors = function(def) {\n  if (def.anchorA) {\n    this.m_localAnchorA.set(this.m_bodyA.getLocalPoint(def.anchorA));\n  } else if (def.localAnchorA) {\n    this.m_localAnchorA.set(def.localAnchorA);\n  }\n\n  if (def.anchorB) {\n    this.m_localAnchorB.set(this.m_bodyB.getLocalPoint(def.anchorB));\n  } else if (def.localAnchorB) {\n    this.m_localAnchorB.set(def.localAnchorB);\n  }\n}\n\n/**\n * The local anchor point relative to bodyA's origin.\n */\nRevoluteJoint.prototype.getLocalAnchorA = function() {\n  return this.m_localAnchorA;\n}\n\n/**\n * The local anchor point relative to bodyB's origin.\n */\nRevoluteJoint.prototype.getLocalAnchorB = function() {\n  return this.m_localAnchorB;\n}\n\n/**\n * Get the reference angle.\n */\nRevoluteJoint.prototype.getReferenceAngle = function() {\n  return this.m_referenceAngle;\n}\n\n/**\n * Get the current joint angle in radians.\n */\nRevoluteJoint.prototype.getJointAngle = function() {\n  var bA = this.m_bodyA;\n  var bB = this.m_bodyB;\n  return bB.m_sweep.a - bA.m_sweep.a - this.m_referenceAngle;\n}\n\n/**\n * Get the current joint angle speed in radians per second.\n */\nRevoluteJoint.prototype.getJointSpeed = function() {\n  var bA = this.m_bodyA;\n  var bB = this.m_bodyB;\n  return bB.m_angularVelocity - bA.m_angularVelocity;\n}\n\n/**\n * Is the joint motor enabled?\n */\nRevoluteJoint.prototype.isMotorEnabled = function() {\n  return this.m_enableMotor;\n}\n\n/**\n * Enable/disable the joint motor.\n */\nRevoluteJoint.prototype.enableMotor = function(flag) {\n  this.m_bodyA.setAwake(true);\n  this.m_bodyB.setAwake(true);\n  this.m_enableMotor = flag;\n}\n\n/**\n * Get the current motor torque given the inverse time step. Unit is N*m.\n */\nRevoluteJoint.prototype.getMotorTorque = function(inv_dt) {\n  return inv_dt * this.m_motorImpulse;\n}\n\n/**\n * Set the motor speed in radians per second.\n */\nRevoluteJoint.prototype.setMotorSpeed = function(speed) {\n  this.m_bodyA.setAwake(true);\n  this.m_bodyB.setAwake(true);\n  this.m_motorSpeed = speed;\n}\n\n/**\n * Get the motor speed in radians per second.\n */\nRevoluteJoint.prototype.getMotorSpeed = function() {\n  return this.m_motorSpeed;\n}\n\n/**\n * Set the maximum motor torque, usually in N-m.\n */\nRevoluteJoint.prototype.setMaxMotorTorque = function(torque) {\n  this.m_bodyA.setAwake(true);\n  this.m_bodyB.setAwake(true);\n  this.m_maxMotorTorque = torque;\n}\n\nRevoluteJoint.prototype.getMaxMotorTorque = function() {\n  return this.m_maxMotorTorque;\n}\n\n/**\n * Is the joint limit enabled?\n */\nRevoluteJoint.prototype.isLimitEnabled = function() {\n  return this.m_enableLimit;\n}\n\n/**\n * Enable/disable the joint limit.\n */\nRevoluteJoint.prototype.enableLimit = function(flag) {\n  if (flag != this.m_enableLimit) {\n    this.m_bodyA.setAwake(true);\n    this.m_bodyB.setAwake(true);\n    this.m_enableLimit = flag;\n    this.m_impulse.z = 0.0;\n  }\n}\n\n/**\n * Get the lower joint limit in radians.\n */\nRevoluteJoint.prototype.getLowerLimit = function() {\n  return this.m_lowerAngle;\n}\n\n/**\n * Get the upper joint limit in radians.\n */\nRevoluteJoint.prototype.getUpperLimit = function() {\n  return this.m_upperAngle;\n}\n\n/**\n * Set the joint limits in radians.\n */\nRevoluteJoint.prototype.setLimits = function(lower, upper) {\n  _ASSERT && common.assert(lower <= upper);\n\n  if (lower != this.m_lowerAngle || upper != this.m_upperAngle) {\n    this.m_bodyA.setAwake(true);\n    this.m_bodyB.setAwake(true);\n    this.m_impulse.z = 0.0;\n    this.m_lowerAngle = lower;\n    this.m_upperAngle = upper;\n  }\n}\n\nRevoluteJoint.prototype.getAnchorA = function() {\n  return this.m_bodyA.getWorldPoint(this.m_localAnchorA);\n}\n\nRevoluteJoint.prototype.getAnchorB = function() {\n  return this.m_bodyB.getWorldPoint(this.m_localAnchorB);\n}\n\n/**\n * Get the reaction force given the inverse time step. Unit is N.\n */\nRevoluteJoint.prototype.getReactionForce = function(inv_dt) {\n  return Vec2.neo(this.m_impulse.x, this.m_impulse.y).mul(inv_dt);\n}\n\n/**\n * Get the reaction torque due to the joint limit given the inverse time step.\n * Unit is N*m.\n */\nRevoluteJoint.prototype.getReactionTorque = function(inv_dt) {\n  return inv_dt * this.m_impulse.z;\n}\n\nRevoluteJoint.prototype.initVelocityConstraints = function(step) {\n  this.m_localCenterA = this.m_bodyA.m_sweep.localCenter;\n  this.m_localCenterB = this.m_bodyB.m_sweep.localCenter;\n  this.m_invMassA = this.m_bodyA.m_invMass;\n  this.m_invMassB = this.m_bodyB.m_invMass;\n  this.m_invIA = this.m_bodyA.m_invI;\n  this.m_invIB = this.m_bodyB.m_invI;\n\n  var aA = this.m_bodyA.c_position.a;\n  var vA = this.m_bodyA.c_velocity.v;\n  var wA = this.m_bodyA.c_velocity.w;\n\n  var aB = this.m_bodyB.c_position.a;\n  var vB = this.m_bodyB.c_velocity.v;\n  var wB = this.m_bodyB.c_velocity.w;\n\n  var qA = Rot.neo(aA);\n  var qB = Rot.neo(aB);\n\n  this.m_rA = Rot.mulVec2(qA, Vec2.sub(this.m_localAnchorA, this.m_localCenterA));\n  this.m_rB = Rot.mulVec2(qB, Vec2.sub(this.m_localAnchorB, this.m_localCenterB));\n\n  // J = [-I -r1_skew I r2_skew]\n  // [ 0 -1 0 1]\n  // r_skew = [-ry; rx]\n\n  // Matlab\n  // K = [ mA+r1y^2*iA+mB+r2y^2*iB, -r1y*iA*r1x-r2y*iB*r2x, -r1y*iA-r2y*iB]\n  // [ -r1y*iA*r1x-r2y*iB*r2x, mA+r1x^2*iA+mB+r2x^2*iB, r1x*iA+r2x*iB]\n  // [ -r1y*iA-r2y*iB, r1x*iA+r2x*iB, iA+iB]\n\n  var mA = this.m_invMassA;\n  var mB = this.m_invMassB; // float\n  var iA = this.m_invIA;\n  var iB = this.m_invIB; // float\n\n  var fixedRotation = (iA + iB === 0.0); // bool\n\n  this.m_mass.ex.x = mA + mB + this.m_rA.y * this.m_rA.y * iA + this.m_rB.y\n      * this.m_rB.y * iB;\n  this.m_mass.ey.x = -this.m_rA.y * this.m_rA.x * iA - this.m_rB.y\n      * this.m_rB.x * iB;\n  this.m_mass.ez.x = -this.m_rA.y * iA - this.m_rB.y * iB;\n  this.m_mass.ex.y = this.m_mass.ey.x;\n  this.m_mass.ey.y = mA + mB + this.m_rA.x * this.m_rA.x * iA + this.m_rB.x\n      * this.m_rB.x * iB;\n  this.m_mass.ez.y = this.m_rA.x * iA + this.m_rB.x * iB;\n  this.m_mass.ex.z = this.m_mass.ez.x;\n  this.m_mass.ey.z = this.m_mass.ez.y;\n  this.m_mass.ez.z = iA + iB;\n\n  this.m_motorMass = iA + iB;\n  if (this.m_motorMass > 0.0) {\n    this.m_motorMass = 1.0 / this.m_motorMass;\n  }\n\n  if (this.m_enableMotor == false || fixedRotation) {\n    this.m_motorImpulse = 0.0;\n  }\n\n  if (this.m_enableLimit && fixedRotation == false) {\n    var jointAngle = aB - aA - this.m_referenceAngle; // float\n\n    if (Math.abs(this.m_upperAngle - this.m_lowerAngle) < 2.0 * Settings.angularSlop) {\n      this.m_limitState = equalLimits;\n\n    } else if (jointAngle <= this.m_lowerAngle) {\n      if (this.m_limitState != atLowerLimit) {\n        this.m_impulse.z = 0.0;\n      }\n      this.m_limitState = atLowerLimit;\n\n    } else if (jointAngle >= this.m_upperAngle) {\n      if (this.m_limitState != atUpperLimit) {\n        this.m_impulse.z = 0.0;\n      }\n      this.m_limitState = atUpperLimit;\n\n    } else {\n      this.m_limitState = inactiveLimit;\n      this.m_impulse.z = 0.0;\n    }\n\n  } else {\n    this.m_limitState = inactiveLimit;\n  }\n\n  if (step.warmStarting) {\n    // Scale impulses to support a variable time step.\n    this.m_impulse.mul(step.dtRatio);\n    this.m_motorImpulse *= step.dtRatio;\n\n    var P = Vec2.neo(this.m_impulse.x, this.m_impulse.y);\n\n    vA.subMul(mA, P);\n    wA -= iA * (Vec2.cross(this.m_rA, P) + this.m_motorImpulse + this.m_impulse.z);\n\n    vB.addMul(mB, P);\n    wB += iB * (Vec2.cross(this.m_rB, P) + this.m_motorImpulse + this.m_impulse.z);\n\n  } else {\n    this.m_impulse.setZero();\n    this.m_motorImpulse = 0.0;\n  }\n\n  this.m_bodyA.c_velocity.v = vA;\n  this.m_bodyA.c_velocity.w = wA;\n  this.m_bodyB.c_velocity.v = vB;\n  this.m_bodyB.c_velocity.w = wB;\n}\n\nRevoluteJoint.prototype.solveVelocityConstraints = function(step) {\n  var vA = this.m_bodyA.c_velocity.v;\n  var wA = this.m_bodyA.c_velocity.w;\n  var vB = this.m_bodyB.c_velocity.v;\n  var wB = this.m_bodyB.c_velocity.w;\n\n  var mA = this.m_invMassA;\n  var mB = this.m_invMassB; // float\n  var iA = this.m_invIA;\n  var iB = this.m_invIB; // float\n\n  var fixedRotation = (iA + iB === 0.0); // bool\n\n  // Solve motor constraint.\n  if (this.m_enableMotor && this.m_limitState != equalLimits\n      && fixedRotation == false) {\n    var Cdot = wB - wA - this.m_motorSpeed; // float\n    var impulse = -this.m_motorMass * Cdot; // float\n    var oldImpulse = this.m_motorImpulse; // float\n    var maxImpulse = step.dt * this.m_maxMotorTorque; // float\n    this.m_motorImpulse = Math.clamp(this.m_motorImpulse + impulse,\n        -maxImpulse, maxImpulse);\n    impulse = this.m_motorImpulse - oldImpulse;\n\n    wA -= iA * impulse;\n    wB += iB * impulse;\n  }\n\n  // Solve limit constraint.\n  if (this.m_enableLimit && this.m_limitState != inactiveLimit\n      && fixedRotation == false) {\n    var Cdot1 = Vec2.zero();\n    Cdot1.addCombine(1, vB, 1, Vec2.cross(wB, this.m_rB));\n    Cdot1.subCombine(1, vA, 1, Vec2.cross(wA, this.m_rA));\n    var Cdot2 = wB - wA; // float\n    var Cdot = Vec3(Cdot1.x, Cdot1.y, Cdot2);\n\n    var impulse = Vec3.neg(this.m_mass.solve33(Cdot)); // Vec3\n\n    if (this.m_limitState == equalLimits) {\n      this.m_impulse.add(impulse);\n\n    } else if (this.m_limitState == atLowerLimit) {\n      var newImpulse = this.m_impulse.z + impulse.z; // float\n\n      if (newImpulse < 0.0) {\n        var rhs = Vec2.combine(-1, Cdot1, this.m_impulse.z, Vec2.neo(this.m_mass.ez.x, this.m_mass.ez.y)); // Vec2\n        var reduced = this.m_mass.solve22(rhs); // Vec2\n        impulse.x = reduced.x;\n        impulse.y = reduced.y;\n        impulse.z = -this.m_impulse.z;\n        this.m_impulse.x += reduced.x;\n        this.m_impulse.y += reduced.y;\n        this.m_impulse.z = 0.0;\n\n      } else {\n        this.m_impulse.add(impulse);\n      }\n\n    } else if (this.m_limitState == atUpperLimit) {\n      var newImpulse = this.m_impulse.z + impulse.z; // float\n\n      if (newImpulse > 0.0) {\n        var rhs = Vec2.combine(-1, Cdot1, this.m_impulse.z, Vec2.neo(this.m_mass.ez.x, this.m_mass.ez.y)); // Vec2\n        var reduced = this.m_mass.solve22(rhs); // Vec2\n        impulse.x = reduced.x;\n        impulse.y = reduced.y;\n        impulse.z = -this.m_impulse.z;\n        this.m_impulse.x += reduced.x;\n        this.m_impulse.y += reduced.y;\n        this.m_impulse.z = 0.0;\n\n      } else {\n        this.m_impulse.add(impulse);\n      }\n    }\n\n    var P = Vec2.neo(impulse.x, impulse.y);\n\n    vA.subMul(mA, P);\n    wA -= iA * (Vec2.cross(this.m_rA, P) + impulse.z);\n\n    vB.addMul(mB, P);\n    wB += iB * (Vec2.cross(this.m_rB, P) + impulse.z);\n\n  } else {\n    // Solve point-to-point constraint\n    var Cdot = Vec2.zero();\n    Cdot.addCombine(1, vB, 1, Vec2.cross(wB, this.m_rB));\n    Cdot.subCombine(1, vA, 1, Vec2.cross(wA, this.m_rA));\n    var impulse = this.m_mass.solve22(Vec2.neg(Cdot)); // Vec2\n\n    this.m_impulse.x += impulse.x;\n    this.m_impulse.y += impulse.y;\n\n    vA.subMul(mA, impulse);\n    wA -= iA * Vec2.cross(this.m_rA, impulse);\n\n    vB.addMul(mB, impulse);\n    wB += iB * Vec2.cross(this.m_rB, impulse);\n  }\n\n  this.m_bodyA.c_velocity.v = vA;\n  this.m_bodyA.c_velocity.w = wA;\n  this.m_bodyB.c_velocity.v = vB;\n  this.m_bodyB.c_velocity.w = wB;\n}\n\nRevoluteJoint.prototype.solvePositionConstraints = function(step) {\n  var cA = this.m_bodyA.c_position.c;\n  var aA = this.m_bodyA.c_position.a;\n  var cB = this.m_bodyB.c_position.c;\n  var aB = this.m_bodyB.c_position.a;\n\n  var qA = Rot.neo(aA);\n  var qB = Rot.neo(aB);\n\n  var angularError = 0.0; // float\n  var positionError = 0.0; // float\n\n  var fixedRotation = (this.m_invIA + this.m_invIB == 0.0); // bool\n\n  // Solve angular limit constraint.\n  if (this.m_enableLimit && this.m_limitState != inactiveLimit\n      && fixedRotation == false) {\n    var angle = aB - aA - this.m_referenceAngle; // float\n    var limitImpulse = 0.0; // float\n\n    if (this.m_limitState == equalLimits) {\n      // Prevent large angular corrections\n      var C = Math.clamp(angle - this.m_lowerAngle,\n          -Settings.maxAngularCorrection, Settings.maxAngularCorrection); // float\n      limitImpulse = -this.m_motorMass * C;\n      angularError = Math.abs(C);\n\n    } else if (this.m_limitState == atLowerLimit) {\n      var C = angle - this.m_lowerAngle; // float\n      angularError = -C;\n\n      // Prevent large angular corrections and allow some slop.\n      C = Math.clamp(C + Settings.angularSlop, -Settings.maxAngularCorrection,\n          0.0);\n      limitImpulse = -this.m_motorMass * C;\n\n    } else if (this.m_limitState == atUpperLimit) {\n      var C = angle - this.m_upperAngle; // float\n      angularError = C;\n\n      // Prevent large angular corrections and allow some slop.\n      C = Math.clamp(C - Settings.angularSlop, 0.0,\n          Settings.maxAngularCorrection);\n      limitImpulse = -this.m_motorMass * C;\n    }\n\n    aA -= this.m_invIA * limitImpulse;\n    aB += this.m_invIB * limitImpulse;\n  }\n\n  // Solve point-to-point constraint.\n  {\n    qA.set(aA);\n    qB.set(aB);\n    var rA = Rot.mulVec2(qA, Vec2.sub(this.m_localAnchorA, this.m_localCenterA)); // Vec2\n    var rB = Rot.mulVec2(qB, Vec2.sub(this.m_localAnchorB, this.m_localCenterB)); // Vec2\n\n    var C = Vec2.zero();\n    C.addCombine(1, cB, 1, rB);\n    C.subCombine(1, cA, 1, rA);\n    positionError = C.length();\n\n    var mA = this.m_invMassA;\n    var mB = this.m_invMassB; // float\n    var iA = this.m_invIA;\n    var iB = this.m_invIB; // float\n\n    var K = new Mat22();\n    K.ex.x = mA + mB + iA * rA.y * rA.y + iB * rB.y * rB.y;\n    K.ex.y = -iA * rA.x * rA.y - iB * rB.x * rB.y;\n    K.ey.x = K.ex.y;\n    K.ey.y = mA + mB + iA * rA.x * rA.x + iB * rB.x * rB.x;\n\n    var impulse = Vec2.neg(K.solve(C)); // Vec2\n\n    cA.subMul(mA, impulse);\n    aA -= iA * Vec2.cross(rA, impulse);\n\n    cB.addMul(mB, impulse);\n    aB += iB * Vec2.cross(rB, impulse);\n  }\n\n  this.m_bodyA.c_position.c.set(cA);\n  this.m_bodyA.c_position.a = aA;\n  this.m_bodyB.c_position.c.set(cB);\n  this.m_bodyB.c_position.a = aB;\n\n  return positionError <= Settings.linearSlop\n      && angularError <= Settings.angularSlop;\n}\n","/*\n * Planck.js\n * The MIT License\n * Copyright (c) 2021 Erin Catto, Ali Shakiba\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 all\n * 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 THE\n * SOFTWARE.\n */\n\nvar _DEBUG = typeof DEBUG === 'undefined' ? false : DEBUG;\nvar _ASSERT = typeof ASSERT === 'undefined' ? false : ASSERT;\n\nmodule.exports = RopeJoint;\n\nvar options = require('../util/options');\nvar Settings = require('../Settings');\n\nvar Math = require('../common/Math');\nvar Vec2 = require('../common/Vec2');\nvar Vec3 = require('../common/Vec3');\nvar Mat22 = require('../common/Mat22');\nvar Mat33 = require('../common/Mat33');\nvar Rot = require('../common/Rot');\nvar Sweep = require('../common/Sweep');\nvar Transform = require('../common/Transform');\nvar Velocity = require('../common/Velocity');\nvar Position = require('../common/Position');\n\nvar Joint = require('../Joint');\nvar Body = require('../Body');\n\nvar inactiveLimit = 0;\nvar atLowerLimit = 1;\nvar atUpperLimit = 2;\nvar equalLimits = 3;\n\nRopeJoint.TYPE = 'rope-joint';\nJoint.TYPES[RopeJoint.TYPE] = RopeJoint;\n\nRopeJoint._super = Joint;\nRopeJoint.prototype = Object.create(RopeJoint._super.prototype);\n\n/**\n * @typedef {Object} RopeJointDef\n *\n * Rope joint definition. This requires two body anchor points and a maximum\n * lengths. Note: by default the connected objects will not collide. see\n * collideConnected in JointDef.\n *\n * @prop {float} maxLength The maximum length of the rope. Warning: this must be\n *       larger than linearSlop or the joint will have no effect.\n *\n * @prop {Vec2} def.localAnchorA The local anchor point relative to bodyA's origin.\n * @prop {Vec2} def.localAnchorB The local anchor point relative to bodyB's origin.\n */\n\nvar DEFAULTS = {\n  maxLength : 0.0,\n};\n\n/**\n * A rope joint enforces a maximum distance between two points on two bodies. It\n * has no other effect.\n * \n * Warning: if you attempt to change the maximum length during the simulation\n * you will get some non-physical behavior.\n * \n * A model that would allow you to dynamically modify the length would have some\n * sponginess, so I chose not to implement it that way. See DistanceJoint if you\n * want to dynamically control length.\n *\n * @param {RopeJointDef} def\n * @param {Body} bodyA\n * @param {Body} bodyB\n */\nfunction RopeJoint(def, bodyA, bodyB, anchor) {\n  if (!(this instanceof RopeJoint)) {\n    return new RopeJoint(def, bodyA, bodyB, anchor);\n  }\n\n  def = options(def, DEFAULTS);\n  Joint.call(this, def, bodyA, bodyB);\n  bodyA = this.m_bodyA;\n  bodyB = this.m_bodyB;\n\n  this.m_type = RopeJoint.TYPE;\n  this.m_localAnchorA = anchor ? bodyA.getLocalPoint(anchor) : def.localAnchorA || Vec2.neo(-1.0, 0.0);\n  this.m_localAnchorB = anchor ? bodyB.getLocalPoint(anchor) : def.localAnchorB || Vec2.neo(1.0, 0.0);\n\n  this.m_maxLength = def.maxLength;\n\n  this.m_mass = 0.0;\n  this.m_impulse = 0.0;\n  this.m_length = 0.0;\n  this.m_state = inactiveLimit;\n\n  // Solver temp\n  this.m_u; // Vec2\n  this.m_rA; // Vec2\n  this.m_rB; // Vec2\n  this.m_localCenterA; // Vec2\n  this.m_localCenterB; // Vec2\n  this.m_invMassA; // float\n  this.m_invMassB; // float\n  this.m_invIA; // float\n  this.m_invIB; // float\n  this.m_mass; // float\n\n  // Limit:\n  // C = norm(pB - pA) - L\n  // u = (pB - pA) / norm(pB - pA)\n  // Cdot = dot(u, vB + cross(wB, rB) - vA - cross(wA, rA))\n  // J = [-u -cross(rA, u) u cross(rB, u)]\n  // K = J * invM * JT\n  // = invMassA + invIA * cross(rA, u)^2 + invMassB + invIB * cross(rB, u)^2\n};\n\nRopeJoint.prototype._serialize = function() {\n  return {\n    type: this.m_type,\n    bodyA: this.m_bodyA,\n    bodyB: this.m_bodyB,\n    collideConnected: this.m_collideConnected,\n\n    localAnchorA: this.m_localAnchorA,\n    localAnchorB: this.m_localAnchorB,\n    maxLength: this.m_maxLength,\n  };\n};\n\nRopeJoint._deserialize = function(data, world, restore) {\n  data = Object.assign({}, data);\n  data.bodyA = restore(Body, data.bodyA, world);\n  data.bodyB = restore(Body, data.bodyB, world);\n  var joint = new RopeJoint(data);\n  return joint;\n};\n\n/**\n * The local anchor point relative to bodyA's origin.\n */\nRopeJoint.prototype.getLocalAnchorA = function() {\n  return this.m_localAnchorA;\n}\n\n/**\n * The local anchor point relative to bodyB's origin.\n */\nRopeJoint.prototype.getLocalAnchorB = function() {\n  return this.m_localAnchorB;\n}\n\n/**\n * Set/Get the maximum length of the rope.\n */\nRopeJoint.prototype.setMaxLength = function(length) {\n  this.m_maxLength = length;\n}\n\nRopeJoint.prototype.getMaxLength = function() {\n  return this.m_maxLength;\n}\n\nRopeJoint.prototype.getLimitState = function() {\n  // TODO LimitState\n  return this.m_state;\n}\n\nRopeJoint.prototype.getAnchorA = function() {\n  return this.m_bodyA.getWorldPoint(this.m_localAnchorA);\n}\n\nRopeJoint.prototype.getAnchorB = function() {\n  return this.m_bodyB.getWorldPoint(this.m_localAnchorB);\n}\n\nRopeJoint.prototype.getReactionForce = function(inv_dt) {\n  return Vec2.mul(this.m_impulse, this.m_u).mul(inv_dt);\n}\n\nRopeJoint.prototype.getReactionTorque = function(inv_dt) {\n  return 0.0;\n}\n\nRopeJoint.prototype.initVelocityConstraints = function(step) {\n  this.m_localCenterA = this.m_bodyA.m_sweep.localCenter;\n  this.m_localCenterB = this.m_bodyB.m_sweep.localCenter;\n  this.m_invMassA = this.m_bodyA.m_invMass;\n  this.m_invMassB = this.m_bodyB.m_invMass;\n  this.m_invIA = this.m_bodyA.m_invI;\n  this.m_invIB = this.m_bodyB.m_invI;\n\n  var cA = this.m_bodyA.c_position.c;\n  var aA = this.m_bodyA.c_position.a;\n  var vA = this.m_bodyA.c_velocity.v;\n  var wA = this.m_bodyA.c_velocity.w;\n\n  var cB = this.m_bodyB.c_position.c;\n  var aB = this.m_bodyB.c_position.a;\n  var vB = this.m_bodyB.c_velocity.v;\n  var wB = this.m_bodyB.c_velocity.w;\n\n  var qA = Rot.neo(aA);\n  var qB = Rot.neo(aB);\n\n  this.m_rA = Rot.mulSub(qA, this.m_localAnchorA, this.m_localCenterA);\n  this.m_rB = Rot.mulSub(qB, this.m_localAnchorB, this.m_localCenterB);\n  this.m_u = Vec2.zero();\n  this.m_u.addCombine(1, cB, 1, this.m_rB);\n  this.m_u.subCombine(1, cA, 1, this.m_rA); // Vec2\n\n  this.m_length = this.m_u.length();\n\n  var C = this.m_length - this.m_maxLength; // float\n  if (C > 0.0) {\n    this.m_state = atUpperLimit;\n  } else {\n    this.m_state = inactiveLimit;\n  }\n\n  if (this.m_length > Settings.linearSlop) {\n    this.m_u.mul(1.0 / this.m_length);\n  } else {\n    this.m_u.setZero();\n    this.m_mass = 0.0;\n    this.m_impulse = 0.0;\n    return;\n  }\n\n  // Compute effective mass.\n  var crA = Vec2.cross(this.m_rA, this.m_u); // float\n  var crB = Vec2.cross(this.m_rB, this.m_u); // float\n  var invMass = this.m_invMassA + this.m_invIA * crA * crA + this.m_invMassB\n      + this.m_invIB * crB * crB; // float\n\n  this.m_mass = invMass != 0.0 ? 1.0 / invMass : 0.0;\n\n  if (step.warmStarting) {\n    // Scale the impulse to support a variable time step.\n    this.m_impulse *= step.dtRatio;\n\n    var P = Vec2.mul(this.m_impulse, this.m_u);\n    \n    vA.subMul(this.m_invMassA, P);\n    wA -= this.m_invIA * Vec2.cross(this.m_rA, P);\n    \n    vB.addMul(this.m_invMassB, P);\n    wB += this.m_invIB * Vec2.cross(this.m_rB, P);\n    \n  } else {\n    this.m_impulse = 0.0;\n  }\n\n  this.m_bodyA.c_velocity.v.set(vA);\n  this.m_bodyA.c_velocity.w = wA;\n  this.m_bodyB.c_velocity.v.set(vB);\n  this.m_bodyB.c_velocity.w = wB;\n}\n\nRopeJoint.prototype.solveVelocityConstraints = function(step) {\n  var vA = this.m_bodyA.c_velocity.v;\n  var wA = this.m_bodyA.c_velocity.w;\n  var vB = this.m_bodyB.c_velocity.v;\n  var wB = this.m_bodyB.c_velocity.w;\n\n  // Cdot = dot(u, v + cross(w, r))\n  var vpA = Vec2.addCross(vA, wA, this.m_rA); // Vec2\n  var vpB = Vec2.addCross(vB, wB, this.m_rB); // Vec2\n  var C = this.m_length - this.m_maxLength; // float\n  var Cdot = Vec2.dot(this.m_u, Vec2.sub(vpB, vpA)); // float\n\n  // Predictive constraint.\n  if (C < 0.0) {\n    Cdot += step.inv_dt * C;\n  }\n\n  var impulse = -this.m_mass * Cdot; // float\n  var oldImpulse = this.m_impulse; // float\n  this.m_impulse = Math.min(0.0, this.m_impulse + impulse);\n  impulse = this.m_impulse - oldImpulse;\n\n  var P = Vec2.mul(impulse, this.m_u); // Vec2\n  vA.subMul(this.m_invMassA, P);\n  wA -= this.m_invIA * Vec2.cross(this.m_rA, P);\n  vB.addMul(this.m_invMassB, P);\n  wB += this.m_invIB * Vec2.cross(this.m_rB, P);\n\n  this.m_bodyA.c_velocity.v = vA;\n  this.m_bodyA.c_velocity.w = wA;\n  this.m_bodyB.c_velocity.v = vB;\n  this.m_bodyB.c_velocity.w = wB;\n}\n\nRopeJoint.prototype.solvePositionConstraints = function(step) {\n  var cA = this.m_bodyA.c_position.c; // Vec2\n  var aA = this.m_bodyA.c_position.a; // float\n  var cB = this.m_bodyB.c_position.c; // Vec2\n  var aB = this.m_bodyB.c_position.a; // float\n\n  var qA = Rot.neo(aA);\n  var qB = Rot.neo(aB);\n\n  var rA = Rot.mulSub(qA, this.m_localAnchorA, this.m_localCenterA);\n  var rB = Rot.mulSub(qB, this.m_localAnchorB, this.m_localCenterB);\n  var u = Vec2.zero();\n  u.addCombine(1, cB, 1, rB);\n  u.subCombine(1, cA, 1, rA); // Vec2\n\n  var length = u.normalize(); // float\n  var C = length - this.m_maxLength; // float\n\n  C = Math.clamp(C, 0.0, Settings.maxLinearCorrection);\n\n  var impulse = -this.m_mass * C; // float\n  var P = Vec2.mul(impulse, u); // Vec2\n\n  cA.subMul(this.m_invMassA, P);\n  aA -= this.m_invIA * Vec2.cross(rA, P);\n  cB.addMul(this.m_invMassB, P);\n  aB += this.m_invIB * Vec2.cross(rB, P);\n\n  this.m_bodyA.c_position.c.set(cA);\n  this.m_bodyA.c_position.a = aA;\n  this.m_bodyB.c_position.c.set(cB);\n  this.m_bodyB.c_position.a = aB;\n\n  return length - this.m_maxLength < Settings.linearSlop;\n}\n","/*\n * Planck.js\n * The MIT License\n * Copyright (c) 2021 Erin Catto, Ali Shakiba\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 all\n * 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 THE\n * SOFTWARE.\n */\n\nvar _DEBUG = typeof DEBUG === 'undefined' ? false : DEBUG;\nvar _ASSERT = typeof ASSERT === 'undefined' ? false : ASSERT;\n\nmodule.exports = WeldJoint;\n\nvar options = require('../util/options');\nvar Settings = require('../Settings');\n\nvar Math = require('../common/Math');\nvar Vec2 = require('../common/Vec2');\nvar Vec3 = require('../common/Vec3');\nvar Mat22 = require('../common/Mat22');\nvar Mat33 = require('../common/Mat33');\nvar Rot = require('../common/Rot');\nvar Sweep = require('../common/Sweep');\nvar Transform = require('../common/Transform');\nvar Velocity = require('../common/Velocity');\nvar Position = require('../common/Position');\n\nvar Joint = require('../Joint');\nvar Body = require('../Body');\n\nWeldJoint.TYPE = 'weld-joint';\nJoint.TYPES[WeldJoint.TYPE] = WeldJoint;\n\nWeldJoint._super = Joint;\nWeldJoint.prototype = Object.create(WeldJoint._super.prototype);\n\n/**\n * @typedef {Object} WeldJointDef\n *\n * Weld joint definition. You need to specify local anchor points where they are\n * attached and the relative body angle. The position of the anchor points is\n * important for computing the reaction torque.\n * \n * @prop {float} frequencyHz The mass-spring-damper frequency in Hertz. Rotation\n *       only. Disable softness with a value of 0.\n * @prop {float} dampingRatio The damping ratio. 0 = no damping, 1 = critical\n *       damping.\n *\n * @prop {Vec2} localAnchorA The local anchor point relative to bodyA's origin.\n * @prop {Vec2} localAnchorB The local anchor point relative to bodyB's origin.\n * @prop {float} referenceAngle The bodyB angle minus bodyA angle in the\n *       reference state (radians).\n */\nvar DEFAULTS = {\n  frequencyHz : 0.0,\n  dampingRatio : 0.0,\n}\n\n/**\n * A weld joint essentially glues two bodies together. A weld joint may distort\n * somewhat because the island constraint solver is approximate.\n *\n * @param {WeldJointDef} def\n * @param {Body} bodyA\n * @param {Body} bodyB\n */\nfunction WeldJoint(def, bodyA, bodyB, anchor) {\n  if (!(this instanceof WeldJoint)) {\n    return new WeldJoint(def, bodyA, bodyB, anchor);\n  }\n\n  def = options(def, DEFAULTS);\n  Joint.call(this, def, bodyA, bodyB);\n  bodyA = this.m_bodyA;\n  bodyB = this.m_bodyB;\n\n  this.m_type = WeldJoint.TYPE;\n\n  this.m_localAnchorA = Vec2.clone(anchor ? bodyA.getLocalPoint(anchor) : def.localAnchorA || Vec2.zero());\n  this.m_localAnchorB = Vec2.clone(anchor ? bodyB.getLocalPoint(anchor) : def.localAnchorB || Vec2.zero());\n  this.m_referenceAngle = Math.isFinite(def.referenceAngle) ? def.referenceAngle : bodyB.getAngle() - bodyA.getAngle();\n\n  this.m_frequencyHz = def.frequencyHz;\n  this.m_dampingRatio = def.dampingRatio;\n\n  this.m_impulse = Vec3();\n\n  this.m_bias = 0.0;\n  this.m_gamma = 0.0;\n\n  // Solver temp\n  this.m_rA; // Vec2\n  this.m_rB; // Vec2\n  this.m_localCenterA; // Vec2\n  this.m_localCenterB; // Vec2\n  this.m_invMassA; // float\n  this.m_invMassB; // float\n  this.m_invIA; // float\n  this.m_invIB; // float\n  this.m_mass = new Mat33();\n\n  // Point-to-point constraint\n  // C = p2 - p1\n  // Cdot = v2 - v1\n  // / = v2 + cross(w2, r2) - v1 - cross(w1, r1)\n  // J = [-I -r1_skew I r2_skew ]\n  // Identity used:\n  // w k % (rx i + ry j) = w * (-ry i + rx j)\n\n  // Angle constraint\n  // C = angle2 - angle1 - referenceAngle\n  // Cdot = w2 - w1\n  // J = [0 0 -1 0 0 1]\n  // K = invI1 + invI2\n}\n\nWeldJoint.prototype._serialize = function() {\n  return {\n    type: this.m_type,\n    bodyA: this.m_bodyA,\n    bodyB: this.m_bodyB,\n    collideConnected: this.m_collideConnected,\n    \n    frequencyHz: this.m_frequencyHz,\n    dampingRatio: this.m_dampingRatio,\n\n    localAnchorA: this.m_localAnchorA,\n    localAnchorB: this.m_localAnchorB,\n    referenceAngle: this.m_referenceAngle,\n  };\n};\n\nWeldJoint._deserialize = function(data, world, restore) {\n  data = Object.assign({}, data);\n  data.bodyA = restore(Body, data.bodyA, world);\n  data.bodyB = restore(Body, data.bodyB, world);\n  var joint = new WeldJoint(data);\n  return joint;\n};\n\n/**\n * @internal\n */\nWeldJoint.prototype._setAnchors = function(def) {\n  if (def.anchorA) {\n    this.m_localAnchorA.set(this.m_bodyA.getLocalPoint(def.anchorA));\n  } else if (def.localAnchorA) {\n    this.m_localAnchorA.set(def.localAnchorA);\n  }\n\n  if (def.anchorB) {\n    this.m_localAnchorB.set(this.m_bodyB.getLocalPoint(def.anchorB));\n  } else if (def.localAnchorB) {\n    this.m_localAnchorB.set(def.localAnchorB);\n  }\n}\n\n/**\n * The local anchor point relative to bodyA's origin.\n */\nWeldJoint.prototype.getLocalAnchorA = function() {\n  return this.m_localAnchorA;\n};\n\n/**\n * The local anchor point relative to bodyB's origin.\n */\nWeldJoint.prototype.getLocalAnchorB = function() {\n  return this.m_localAnchorB;\n};\n\n/**\n * Get the reference angle.\n */\nWeldJoint.prototype.getReferenceAngle = function() {\n  return this.m_referenceAngle;\n};\n\n/**\n * Set/get frequency in Hz.\n */\nWeldJoint.prototype.setFrequency = function(hz) {\n  this.m_frequencyHz = hz;\n};\n\nWeldJoint.prototype.getFrequency = function() {\n  return this.m_frequencyHz;\n};\n\n/**\n * Set/get damping ratio.\n */\nWeldJoint.prototype.setDampingRatio = function(ratio) {\n  this.m_dampingRatio = ratio;\n};\n\nWeldJoint.prototype.getDampingRatio = function() {\n  return this.m_dampingRatio;\n};\n\nWeldJoint.prototype.getAnchorA = function() {\n  return this.m_bodyA.getWorldPoint(this.m_localAnchorA);\n};\n\nWeldJoint.prototype.getAnchorB = function() {\n  return this.m_bodyB.getWorldPoint(this.m_localAnchorB);\n};\n\nWeldJoint.prototype.getReactionForce = function(inv_dt) {\n  return Vec2.neo(this.m_impulse.x, this.m_impulse.y).mul(inv_dt);\n};\n\nWeldJoint.prototype.getReactionTorque = function(inv_dt) {\n  return inv_dt * this.m_impulse.z;\n};\n\nWeldJoint.prototype.initVelocityConstraints = function(step) {\n  this.m_localCenterA = this.m_bodyA.m_sweep.localCenter;\n  this.m_localCenterB = this.m_bodyB.m_sweep.localCenter;\n  this.m_invMassA = this.m_bodyA.m_invMass;\n  this.m_invMassB = this.m_bodyB.m_invMass;\n  this.m_invIA = this.m_bodyA.m_invI;\n  this.m_invIB = this.m_bodyB.m_invI;\n\n  var aA = this.m_bodyA.c_position.a;\n  var vA = this.m_bodyA.c_velocity.v;\n  var wA = this.m_bodyA.c_velocity.w;\n\n  var aB = this.m_bodyB.c_position.a;\n  var vB = this.m_bodyB.c_velocity.v;\n  var wB = this.m_bodyB.c_velocity.w;\n\n  var qA = Rot.neo(aA), qB = Rot.neo(aB);\n\n  this.m_rA = Rot.mulVec2(qA, Vec2.sub(this.m_localAnchorA, this.m_localCenterA));\n  this.m_rB = Rot.mulVec2(qB, Vec2.sub(this.m_localAnchorB, this.m_localCenterB));\n\n  // J = [-I -r1_skew I r2_skew]\n  // [ 0 -1 0 1]\n  // r_skew = [-ry; rx]\n\n  // Matlab\n  // K = [ mA+r1y^2*iA+mB+r2y^2*iB, -r1y*iA*r1x-r2y*iB*r2x, -r1y*iA-r2y*iB]\n  // [ -r1y*iA*r1x-r2y*iB*r2x, mA+r1x^2*iA+mB+r2x^2*iB, r1x*iA+r2x*iB]\n  // [ -r1y*iA-r2y*iB, r1x*iA+r2x*iB, iA+iB]\n\n  var mA = this.m_invMassA;\n  var mB = this.m_invMassB; // float\n  var iA = this.m_invIA;\n  var iB = this.m_invIB; // float\n\n  var K = new Mat33();\n  K.ex.x = mA + mB + this.m_rA.y * this.m_rA.y * iA + this.m_rB.y * this.m_rB.y\n      * iB;\n  K.ey.x = -this.m_rA.y * this.m_rA.x * iA - this.m_rB.y * this.m_rB.x * iB;\n  K.ez.x = -this.m_rA.y * iA - this.m_rB.y * iB;\n  K.ex.y = K.ey.x;\n  K.ey.y = mA + mB + this.m_rA.x * this.m_rA.x * iA + this.m_rB.x * this.m_rB.x\n      * iB;\n  K.ez.y = this.m_rA.x * iA + this.m_rB.x * iB;\n  K.ex.z = K.ez.x;\n  K.ey.z = K.ez.y;\n  K.ez.z = iA + iB;\n\n  if (this.m_frequencyHz > 0.0) {\n    K.getInverse22(this.m_mass);\n\n    var invM = iA + iB; // float\n    var m = invM > 0.0 ? 1.0 / invM : 0.0; // float\n\n    var C = aB - aA - this.m_referenceAngle; // float\n\n    // Frequency\n    var omega = 2.0 * Math.PI * this.m_frequencyHz; // float\n\n    // Damping coefficient\n    var d = 2.0 * m * this.m_dampingRatio * omega; // float\n\n    // Spring stiffness\n    var k = m * omega * omega; // float\n\n    // magic formulas\n    var h = step.dt; // float\n    this.m_gamma = h * (d + h * k);\n    this.m_gamma = this.m_gamma != 0.0 ? 1.0 / this.m_gamma : 0.0;\n    this.m_bias = C * h * k * this.m_gamma;\n\n    invM += this.m_gamma;\n    this.m_mass.ez.z = invM != 0.0 ? 1.0 / invM : 0.0;\n  } else if (K.ez.z == 0.0) {\n    K.getInverse22(this.m_mass);\n    this.m_gamma = 0.0;\n    this.m_bias = 0.0;\n  } else {\n    K.getSymInverse33(this.m_mass);\n    this.m_gamma = 0.0;\n    this.m_bias = 0.0;\n  }\n\n  if (step.warmStarting) {\n    // Scale impulses to support a variable time step.\n    this.m_impulse.mul(step.dtRatio);\n\n    var P = Vec2.neo(this.m_impulse.x, this.m_impulse.y);\n\n    vA.subMul(mA, P);\n    wA -= iA * (Vec2.cross(this.m_rA, P) + this.m_impulse.z);\n\n    vB.addMul(mB, P);\n    wB += iB * (Vec2.cross(this.m_rB, P) + this.m_impulse.z);\n\n  } else {\n    this.m_impulse.setZero();\n  }\n\n  this.m_bodyA.c_velocity.v = vA;\n  this.m_bodyA.c_velocity.w = wA;\n  this.m_bodyB.c_velocity.v = vB;\n  this.m_bodyB.c_velocity.w = wB;\n}\n\nWeldJoint.prototype.solveVelocityConstraints = function(step) {\n  var vA = this.m_bodyA.c_velocity.v;\n  var wA = this.m_bodyA.c_velocity.w;\n  var vB = this.m_bodyB.c_velocity.v;\n  var wB = this.m_bodyB.c_velocity.w;\n\n  var mA = this.m_invMassA;\n  var mB = this.m_invMassB; // float\n  var iA = this.m_invIA;\n  var iB = this.m_invIB; // float\n\n  if (this.m_frequencyHz > 0.0) {\n    var Cdot2 = wB - wA; // float\n\n    var impulse2 = -this.m_mass.ez.z\n        * (Cdot2 + this.m_bias + this.m_gamma * this.m_impulse.z); // float\n    this.m_impulse.z += impulse2;\n\n    wA -= iA * impulse2;\n    wB += iB * impulse2;\n\n    var Cdot1 = Vec2.zero();\n    Cdot1.addCombine(1, vB, 1, Vec2.cross(wB, this.m_rB));\n    Cdot1.subCombine(1, vA, 1, Vec2.cross(wA, this.m_rA)); // Vec2\n\n    var impulse1 = Vec2.neg(Mat33.mulVec2(this.m_mass, Cdot1)); // Vec2\n    this.m_impulse.x += impulse1.x;\n    this.m_impulse.y += impulse1.y;\n\n    var P = Vec2.clone(impulse1); // Vec2\n\n    vA.subMul(mA, P);\n    wA -= iA * Vec2.cross(this.m_rA, P);\n\n    vB.addMul(mB, P);\n    wB += iB * Vec2.cross(this.m_rB, P);\n  } else {\n    var Cdot1 = Vec2.zero();\n    Cdot1.addCombine(1, vB, 1, Vec2.cross(wB, this.m_rB));\n    Cdot1.subCombine(1, vA, 1, Vec2.cross(wA, this.m_rA)); // Vec2\n    var Cdot2 = wB - wA; // float\n    var Cdot = Vec3(Cdot1.x, Cdot1.y, Cdot2); // Vec3\n\n    var impulse = Vec3.neg(Mat33.mulVec3(this.m_mass, Cdot)); // Vec3\n    this.m_impulse.add(impulse);\n\n    var P = Vec2.neo(impulse.x, impulse.y);\n\n    vA.subMul(mA, P);\n    wA -= iA * (Vec2.cross(this.m_rA, P) + impulse.z);\n\n    vB.addMul(mB, P);\n    wB += iB * (Vec2.cross(this.m_rB, P) + impulse.z);\n  }\n\n  this.m_bodyA.c_velocity.v = vA;\n  this.m_bodyA.c_velocity.w = wA;\n  this.m_bodyB.c_velocity.v = vB;\n  this.m_bodyB.c_velocity.w = wB;\n}\n\nWeldJoint.prototype.solvePositionConstraints = function(step) {\n  var cA = this.m_bodyA.c_position.c;\n  var aA = this.m_bodyA.c_position.a;\n  var cB = this.m_bodyB.c_position.c;\n  var aB = this.m_bodyB.c_position.a;\n\n  var qA = Rot.neo(aA), qB = Rot.neo(aB);\n\n  var mA = this.m_invMassA, mB = this.m_invMassB; // float\n  var iA = this.m_invIA, iB = this.m_invIB; // float\n\n  var rA = Rot.mulVec2(qA, Vec2.sub(this.m_localAnchorA, this.m_localCenterA));\n  var rB = Rot.mulVec2(qB, Vec2.sub(this.m_localAnchorB, this.m_localCenterB));\n\n  var positionError, angularError; // float\n\n  var K = new Mat33();\n  K.ex.x = mA + mB + rA.y * rA.y * iA + rB.y * rB.y * iB;\n  K.ey.x = -rA.y * rA.x * iA - rB.y * rB.x * iB;\n  K.ez.x = -rA.y * iA - rB.y * iB;\n  K.ex.y = K.ey.x;\n  K.ey.y = mA + mB + rA.x * rA.x * iA + rB.x * rB.x * iB;\n  K.ez.y = rA.x * iA + rB.x * iB;\n  K.ex.z = K.ez.x;\n  K.ey.z = K.ez.y;\n  K.ez.z = iA + iB;\n\n  if (this.m_frequencyHz > 0.0) {\n    var C1 = Vec2.zero();\n    C1.addCombine(1, cB, 1, rB);\n    C1.subCombine(1, cA, 1, rA); // Vec2\n\n    positionError = C1.length();\n    angularError = 0.0;\n\n    var P = Vec2.neg(K.solve22(C1)); // Vec2\n\n    cA.subMul(mA, P);\n    aA -= iA * Vec2.cross(rA, P);\n\n    cB.addMul(mB, P);\n    aB += iB * Vec2.cross(rB, P);\n  } else {\n    var C1 = Vec2.zero();\n    C1.addCombine(1, cB, 1, rB);\n    C1.subCombine(1, cA, 1, rA);\n\n    var C2 = aB - aA - this.m_referenceAngle; // float\n\n    positionError = C1.length();\n    angularError = Math.abs(C2);\n\n    var C = Vec3(C1.x, C1.y, C2);\n\n    var impulse = Vec3();\n    if (K.ez.z > 0.0) {\n      impulse = Vec3.neg(K.solve33(C));\n    } else {\n      var impulse2 = Vec2.neg(K.solve22(C1));\n      impulse.set(impulse2.x, impulse2.y, 0.0);\n    }\n\n    var P = Vec2.neo(impulse.x, impulse.y);\n\n    cA.subMul(mA, P);\n    aA -= iA * (Vec2.cross(rA, P) + impulse.z);\n\n    cB.addMul(mB, P);\n    aB += iB * (Vec2.cross(rB, P) + impulse.z);\n  }\n\n  this.m_bodyA.c_position.c = cA;\n  this.m_bodyA.c_position.a = aA;\n  this.m_bodyB.c_position.c = cB;\n  this.m_bodyB.c_position.a = aB;\n\n  return positionError <= Settings.linearSlop\n      && angularError <= Settings.angularSlop;\n}\n","/*\n * Planck.js\n * The MIT License\n * Copyright (c) 2021 Erin Catto, Ali Shakiba\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 all\n * 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 THE\n * SOFTWARE.\n */\n\nvar _DEBUG = typeof DEBUG === 'undefined' ? false : DEBUG;\nvar _ASSERT = typeof ASSERT === 'undefined' ? false : ASSERT;\n\nmodule.exports = WheelJoint;\n\nvar options = require('../util/options');\nvar Settings = require('../Settings');\n\nvar Math = require('../common/Math');\nvar Vec2 = require('../common/Vec2');\nvar Vec3 = require('../common/Vec3');\nvar Mat22 = require('../common/Mat22');\nvar Mat33 = require('../common/Mat33');\nvar Rot = require('../common/Rot');\nvar Sweep = require('../common/Sweep');\nvar Transform = require('../common/Transform');\nvar Velocity = require('../common/Velocity');\nvar Position = require('../common/Position');\n\nvar Joint = require('../Joint');\nvar Body = require('../Body');\n\nWheelJoint.TYPE = 'wheel-joint';\nJoint.TYPES[WheelJoint.TYPE] = WheelJoint;\n\nWheelJoint._super = Joint;\nWheelJoint.prototype = Object.create(WheelJoint._super.prototype);\n\n/**\n * @typedef {Object} WheelJointDef\n *\n * Wheel joint definition. This requires defining a line of motion using an axis\n * and an anchor point. The definition uses local anchor points and a local axis\n * so that the initial configuration can violate the constraint slightly. The\n * joint translation is zero when the local anchor points coincide in world\n * space. Using local anchors and a local axis helps when saving and loading a\n * game.\n *\n * @prop {boolean} enableMotor Enable/disable the joint motor.\n * @prop {float} maxMotorTorque The maximum motor torque, usually in N-m.\n * @prop {float} motorSpeed The desired motor speed in radians per second.\n * @prop {float} frequencyHz Suspension frequency, zero indicates no suspension.\n * @prop {float} dampingRatio Suspension damping ratio, one indicates critical\n *       damping.\n *\n * @prop {Vec2} localAnchorA The local anchor point relative to bodyA's origin.\n * @prop {Vec2} localAnchorB The local anchor point relative to bodyB's origin.\n * @prop {Vec2} localAxisA The local translation axis in bodyA.\n */\nvar DEFAULTS = {\n  enableMotor : false,\n  maxMotorTorque : 0.0,\n  motorSpeed : 0.0,\n  frequencyHz : 2.0,\n  dampingRatio : 0.7,\n};\n\n/**\n * A wheel joint. This joint provides two degrees of freedom: translation along\n * an axis fixed in bodyA and rotation in the plane. In other words, it is a\n * point to line constraint with a rotational motor and a linear spring/damper.\n * This joint is designed for vehicle suspensions.\n *\n * @param {WheelJointDef} def\n * @param {Body} bodyA\n * @param {Body} bodyB\n */\nfunction WheelJoint(def, bodyA, bodyB, anchor, axis) {\n  if (!(this instanceof WheelJoint)) {\n    return new WheelJoint(def, bodyA, bodyB, anchor, axis);\n  }\n\n  def = options(def, DEFAULTS);\n  Joint.call(this, def, bodyA, bodyB);\n  bodyA = this.m_bodyA;\n  bodyB = this.m_bodyB;\n\n  this.m_type = WheelJoint.TYPE;\n\n  this.m_localAnchorA = Vec2.clone(anchor ? bodyA.getLocalPoint(anchor) : def.localAnchorA || Vec2.zero());\n  this.m_localAnchorB = Vec2.clone(anchor ? bodyB.getLocalPoint(anchor) : def.localAnchorB || Vec2.zero());\n  this.m_localXAxisA = Vec2.clone(axis ? bodyA.getLocalVector(axis) : def.localAxisA || def.localAxis || Vec2.neo(1.0, 0.0));\n  this.m_localYAxisA = Vec2.cross(1.0, this.m_localXAxisA);\n\n  this.m_mass = 0.0;\n  this.m_impulse = 0.0;\n  this.m_motorMass = 0.0;\n  this.m_motorImpulse = 0.0;\n  this.m_springMass = 0.0;\n  this.m_springImpulse = 0.0;\n\n  this.m_maxMotorTorque = def.maxMotorTorque;\n  this.m_motorSpeed = def.motorSpeed;\n  this.m_enableMotor = def.enableMotor;\n\n  this.m_frequencyHz = def.frequencyHz;\n  this.m_dampingRatio = def.dampingRatio;\n\n  this.m_bias = 0.0;\n  this.m_gamma = 0.0;\n\n  // Solver temp\n  this.m_localCenterA; // Vec2\n  this.m_localCenterB; // Vec2\n  this.m_invMassA; // float\n  this.m_invMassB; // float\n  this.m_invIA; // float\n  this.m_invIB; // float\n\n  this.m_ax = Vec2.zero();\n  this.m_ay = Vec2.zero(); // Vec2\n  this.m_sAx;\n  this.m_sBx; // float\n  this.m_sAy;\n  this.m_sBy; // float\n\n  // Linear constraint (point-to-line)\n  // d = pB - pA = xB + rB - xA - rA\n  // C = dot(ay, d)\n  // Cdot = dot(d, cross(wA, ay)) + dot(ay, vB + cross(wB, rB) - vA - cross(wA,\n  // rA))\n  // = -dot(ay, vA) - dot(cross(d + rA, ay), wA) + dot(ay, vB) + dot(cross(rB,\n  // ay), vB)\n  // J = [-ay, -cross(d + rA, ay), ay, cross(rB, ay)]\n\n  // Spring linear constraint\n  // C = dot(ax, d)\n  // Cdot = = -dot(ax, vA) - dot(cross(d + rA, ax), wA) + dot(ax, vB) +\n  // dot(cross(rB, ax), vB)\n  // J = [-ax -cross(d+rA, ax) ax cross(rB, ax)]\n\n  // Motor rotational constraint\n  // Cdot = wB - wA\n  // J = [0 0 -1 0 0 1]\n}\n\nWheelJoint.prototype._serialize = function() {\n  return {\n    type: this.m_type,\n    bodyA: this.m_bodyA,\n    bodyB: this.m_bodyB,\n    collideConnected: this.m_collideConnected,\n\n    enableMotor: this.m_enableMotor,\n    maxMotorTorque: this.m_maxMotorTorque,\n    motorSpeed: this.m_motorSpeed,\n    frequencyHz: this.m_frequencyHz,\n    dampingRatio: this.m_dampingRatio,\n\n    localAnchorA: this.m_localAnchorA,\n    localAnchorB: this.m_localAnchorB,\n    localAxisA: this.m_localXAxisA,\n  };\n};\n\nWheelJoint._deserialize = function(data, world, restore) {\n  data = Object.assign({}, data);\n  data.bodyA = restore(Body, data.bodyA, world);\n  data.bodyB = restore(Body, data.bodyB, world);\n  var joint = new WheelJoint(data);\n  return joint;\n};\n\n/**\n * @internal\n */\nWheelJoint.prototype._setAnchors = function(def) {\n  if (def.anchorA) {\n    this.m_localAnchorA.set(this.m_bodyA.getLocalPoint(def.anchorA));\n  } else if (def.localAnchorA) {\n    this.m_localAnchorA.set(def.localAnchorA);\n  }\n\n  if (def.anchorB) {\n    this.m_localAnchorB.set(this.m_bodyB.getLocalPoint(def.anchorB));\n  } else if (def.localAnchorB) {\n    this.m_localAnchorB.set(def.localAnchorB);\n  }\n\n  if (def.localAxisA) {\n    this.m_localXAxisA.set(def.localAxisA);\n    this.m_localYAxisA.set(Vec2.cross(1.0, def.localAxisA));\n  }\n}\n\n/**\n * The local anchor point relative to bodyA's origin.\n */\nWheelJoint.prototype.getLocalAnchorA = function() {\n  return this.m_localAnchorA;\n}\n\n/**\n * The local anchor point relative to bodyB's origin.\n */\nWheelJoint.prototype.getLocalAnchorB = function() {\n  return this.m_localAnchorB;\n}\n\n/**\n * The local joint axis relative to bodyA.\n */\nWheelJoint.prototype.getLocalAxisA = function() {\n  return this.m_localXAxisA;\n}\n\n/**\n * Get the current joint translation, usually in meters.\n */\nWheelJoint.prototype.getJointTranslation = function() {\n  var bA = this.m_bodyA;\n  var bB = this.m_bodyB;\n\n  var pA = bA.getWorldPoint(this.m_localAnchorA); // Vec2\n  var pB = bB.getWorldPoint(this.m_localAnchorB); // Vec2\n  var d = Vec2.sub(pB, pA); // Vec2\n  var axis = bA.getWorldVector(this.m_localXAxisA); // Vec2\n\n  var translation = Vec2.dot(d, axis); // float\n  return translation;\n}\n\n/**\n * Get the current joint translation speed, usually in meters per second.\n */\nWheelJoint.prototype.getJointSpeed = function() {\n  var wA = this.m_bodyA.m_angularVelocity;\n  var wB = this.m_bodyB.m_angularVelocity;\n  return wB - wA;\n}\n\n/**\n * Is the joint motor enabled?\n */\nWheelJoint.prototype.isMotorEnabled = function() {\n  return this.m_enableMotor;\n}\n\n/**\n * Enable/disable the joint motor.\n */\nWheelJoint.prototype.enableMotor = function(flag) {\n  this.m_bodyA.setAwake(true);\n  this.m_bodyB.setAwake(true);\n  this.m_enableMotor = flag;\n}\n\n/**\n * Set the motor speed, usually in radians per second.\n */\nWheelJoint.prototype.setMotorSpeed = function(speed) {\n  this.m_bodyA.setAwake(true);\n  this.m_bodyB.setAwake(true);\n  this.m_motorSpeed = speed;\n}\n\n/**\n * Get the motor speed, usually in radians per second.\n */\nWheelJoint.prototype.getMotorSpeed = function() {\n  return this.m_motorSpeed;\n}\n\n/**\n * Set/Get the maximum motor force, usually in N-m.\n */\nWheelJoint.prototype.setMaxMotorTorque = function(torque) {\n  this.m_bodyA.setAwake(true);\n  this.m_bodyB.setAwake(true);\n  this.m_maxMotorTorque = torque;\n}\n\nWheelJoint.prototype.getMaxMotorTorque = function() {\n  return this.m_maxMotorTorque;\n}\n\n/**\n * Get the current motor torque given the inverse time step, usually in N-m.\n */\nWheelJoint.prototype.getMotorTorque = function(inv_dt) {\n  return inv_dt * this.m_motorImpulse;\n}\n\n/**\n * Set/Get the spring frequency in hertz. Setting the frequency to zero disables\n * the spring.\n */\nWheelJoint.prototype.setSpringFrequencyHz = function(hz) {\n  this.m_frequencyHz = hz;\n}\n\nWheelJoint.prototype.getSpringFrequencyHz = function() {\n  return this.m_frequencyHz;\n}\n\n/**\n * Set/Get the spring damping ratio\n */\nWheelJoint.prototype.setSpringDampingRatio = function(ratio) {\n  this.m_dampingRatio = ratio;\n}\n\nWheelJoint.prototype.getSpringDampingRatio = function() {\n  return this.m_dampingRatio;\n}\n\nWheelJoint.prototype.getAnchorA = function() {\n  return this.m_bodyA.getWorldPoint(this.m_localAnchorA);\n}\n\nWheelJoint.prototype.getAnchorB = function() {\n  return this.m_bodyB.getWorldPoint(this.m_localAnchorB);\n}\n\nWheelJoint.prototype.getReactionForce = function(inv_dt) {\n  return Vec2.combine(this.m_impulse, this.m_ay, this.m_springImpulse, this.m_ax).mul(inv_dt);\n}\n\nWheelJoint.prototype.getReactionTorque = function(inv_dt) {\n  return inv_dt * this.m_motorImpulse;\n}\n\nWheelJoint.prototype.initVelocityConstraints = function(step) {\n  this.m_localCenterA = this.m_bodyA.m_sweep.localCenter;\n  this.m_localCenterB = this.m_bodyB.m_sweep.localCenter;\n  this.m_invMassA = this.m_bodyA.m_invMass;\n  this.m_invMassB = this.m_bodyB.m_invMass;\n  this.m_invIA = this.m_bodyA.m_invI;\n  this.m_invIB = this.m_bodyB.m_invI;\n\n  var mA = this.m_invMassA;\n  var mB = this.m_invMassB; // float\n  var iA = this.m_invIA;\n  var iB = this.m_invIB; // float\n\n  var cA = this.m_bodyA.c_position.c;\n  var aA = this.m_bodyA.c_position.a;\n  var vA = this.m_bodyA.c_velocity.v;\n  var wA = this.m_bodyA.c_velocity.w;\n\n  var cB = this.m_bodyB.c_position.c;\n  var aB = this.m_bodyB.c_position.a;\n  var vB = this.m_bodyB.c_velocity.v;\n  var wB = this.m_bodyB.c_velocity.w;\n\n  var qA = Rot.neo(aA);\n  var qB = Rot.neo(aB);\n\n  // Compute the effective masses.\n  var rA = Rot.mulVec2(qA, Vec2.sub(this.m_localAnchorA, this.m_localCenterA));\n  var rB = Rot.mulVec2(qB, Vec2.sub(this.m_localAnchorB, this.m_localCenterB));\n  var d = Vec2.zero();\n  d.addCombine(1, cB, 1, rB);\n  d.subCombine(1, cA, 1, rA); // Vec2\n\n  // Point to line constraint\n  {\n    this.m_ay = Rot.mulVec2(qA, this.m_localYAxisA);\n    this.m_sAy = Vec2.cross(Vec2.add(d, rA), this.m_ay);\n    this.m_sBy = Vec2.cross(rB, this.m_ay);\n\n    this.m_mass = mA + mB + iA * this.m_sAy * this.m_sAy + iB * this.m_sBy\n        * this.m_sBy;\n\n    if (this.m_mass > 0.0) {\n      this.m_mass = 1.0 / this.m_mass;\n    }\n  }\n\n  // Spring constraint\n  this.m_springMass = 0.0;\n  this.m_bias = 0.0;\n  this.m_gamma = 0.0;\n  if (this.m_frequencyHz > 0.0) {\n    this.m_ax = Rot.mulVec2(qA, this.m_localXAxisA);\n    this.m_sAx = Vec2.cross(Vec2.add(d, rA), this.m_ax);\n    this.m_sBx = Vec2.cross(rB, this.m_ax);\n\n    var invMass = mA + mB + iA * this.m_sAx * this.m_sAx + iB * this.m_sBx\n        * this.m_sBx; // float\n\n    if (invMass > 0.0) {\n      this.m_springMass = 1.0 / invMass;\n\n      var C = Vec2.dot(d, this.m_ax); // float\n\n      // Frequency\n      var omega = 2.0 * Math.PI * this.m_frequencyHz; // float\n\n      // Damping coefficient\n      var d = 2.0 * this.m_springMass * this.m_dampingRatio * omega; // float\n\n      // Spring stiffness\n      var k = this.m_springMass * omega * omega; // float\n\n      // magic formulas\n      var h = step.dt; // float\n      this.m_gamma = h * (d + h * k);\n      if (this.m_gamma > 0.0) {\n        this.m_gamma = 1.0 / this.m_gamma;\n      }\n\n      this.m_bias = C * h * k * this.m_gamma;\n\n      this.m_springMass = invMass + this.m_gamma;\n      if (this.m_springMass > 0.0) {\n        this.m_springMass = 1.0 / this.m_springMass;\n      }\n    }\n  } else {\n    this.m_springImpulse = 0.0;\n  }\n\n  // Rotational motor\n  if (this.m_enableMotor) {\n    this.m_motorMass = iA + iB;\n    if (this.m_motorMass > 0.0) {\n      this.m_motorMass = 1.0 / this.m_motorMass;\n    }\n  } else {\n    this.m_motorMass = 0.0;\n    this.m_motorImpulse = 0.0;\n  }\n\n  if (step.warmStarting) {\n    // Account for variable time step.\n    this.m_impulse *= step.dtRatio;\n    this.m_springImpulse *= step.dtRatio;\n    this.m_motorImpulse *= step.dtRatio;\n\n    var P = Vec2.combine(this.m_impulse, this.m_ay, this.m_springImpulse, this.m_ax);\n    var LA = this.m_impulse * this.m_sAy + this.m_springImpulse * this.m_sAx + this.m_motorImpulse;\n    var LB = this.m_impulse * this.m_sBy + this.m_springImpulse * this.m_sBx + this.m_motorImpulse;\n\n    vA.subMul(this.m_invMassA, P);\n    wA -= this.m_invIA * LA;\n\n    vB.addMul(this.m_invMassB, P);\n    wB += this.m_invIB * LB;\n\n  } else {\n    this.m_impulse = 0.0;\n    this.m_springImpulse = 0.0;\n    this.m_motorImpulse = 0.0;\n  }\n\n  this.m_bodyA.c_velocity.v.set(vA);\n  this.m_bodyA.c_velocity.w = wA;\n  this.m_bodyB.c_velocity.v.set(vB);\n  this.m_bodyB.c_velocity.w = wB;\n}\n\nWheelJoint.prototype.solveVelocityConstraints = function(step) {\n  var mA = this.m_invMassA;\n  var mB = this.m_invMassB; // float\n  var iA = this.m_invIA;\n  var iB = this.m_invIB; // float\n\n  var vA = this.m_bodyA.c_velocity.v;\n  var wA = this.m_bodyA.c_velocity.w;\n  var vB = this.m_bodyB.c_velocity.v;\n  var wB = this.m_bodyB.c_velocity.w;\n\n  // Solve spring constraint\n  {\n    var Cdot = Vec2.dot(this.m_ax, vB) - Vec2.dot(this.m_ax, vA) + this.m_sBx\n        * wB - this.m_sAx * wA; // float\n    var impulse = -this.m_springMass\n        * (Cdot + this.m_bias + this.m_gamma * this.m_springImpulse); // float\n    this.m_springImpulse += impulse;\n\n    var P = Vec2.mul(impulse, this.m_ax); // Vec2\n    var LA = impulse * this.m_sAx; // float\n    var LB = impulse * this.m_sBx; // float\n\n    vA.subMul(mA, P);\n    wA -= iA * LA;\n\n    vB.addMul(mB, P);\n    wB += iB * LB;\n  }\n\n  // Solve rotational motor constraint\n  {\n    var Cdot = wB - wA - this.m_motorSpeed; // float\n    var impulse = -this.m_motorMass * Cdot; // float\n\n    var oldImpulse = this.m_motorImpulse; // float\n    var maxImpulse = step.dt * this.m_maxMotorTorque; // float\n    this.m_motorImpulse = Math.clamp(this.m_motorImpulse + impulse,\n        -maxImpulse, maxImpulse);\n    impulse = this.m_motorImpulse - oldImpulse;\n\n    wA -= iA * impulse;\n    wB += iB * impulse;\n  }\n\n  // Solve point to line constraint\n  {\n    var Cdot = Vec2.dot(this.m_ay, vB) - Vec2.dot(this.m_ay, vA) + this.m_sBy\n        * wB - this.m_sAy * wA; // float\n    var impulse = -this.m_mass * Cdot; // float\n    this.m_impulse += impulse;\n\n    var P = Vec2.mul(impulse, this.m_ay); // Vec2\n    var LA = impulse * this.m_sAy; // float\n    var LB = impulse * this.m_sBy; // float\n\n    vA.subMul(mA, P);\n    wA -= iA * LA;\n\n    vB.addMul(mB, P);\n    wB += iB * LB;\n  }\n\n  this.m_bodyA.c_velocity.v.set(vA);\n  this.m_bodyA.c_velocity.w = wA;\n  this.m_bodyB.c_velocity.v.set(vB);\n  this.m_bodyB.c_velocity.w = wB;\n}\n\nWheelJoint.prototype.solvePositionConstraints = function(step) {\n  var cA = this.m_bodyA.c_position.c;\n  var aA = this.m_bodyA.c_position.a;\n  var cB = this.m_bodyB.c_position.c;\n  var aB = this.m_bodyB.c_position.a;\n\n  var qA = Rot.neo(aA);\n  var qB = Rot.neo(aB);\n\n  var rA = Rot.mulVec2(qA, Vec2.sub(this.m_localAnchorA, this.m_localCenterA));\n  var rB = Rot.mulVec2(qB, Vec2.sub(this.m_localAnchorB, this.m_localCenterB));\n  var d = Vec2.zero();\n  d.addCombine(1, cB, 1, rB);\n  d.subCombine(1, cA, 1, rA);\n\n  var ay = Rot.mulVec2(qA, this.m_localYAxisA);\n\n  var sAy = Vec2.cross(Vec2.add(d, rA), ay); // float\n  var sBy = Vec2.cross(rB, ay); // float\n\n  var C = Vec2.dot(d, ay); // float\n\n  var k = this.m_invMassA + this.m_invMassB + this.m_invIA * this.m_sAy\n      * this.m_sAy + this.m_invIB * this.m_sBy * this.m_sBy; // float\n\n  var impulse; // float\n  if (k != 0.0) {\n    impulse = -C / k;\n  } else {\n    impulse = 0.0;\n  }\n\n  var P = Vec2.mul(impulse, ay); // Vec2\n  var LA = impulse * sAy; // float\n  var LB = impulse * sBy; // float\n\n  cA.subMul(this.m_invMassA, P);\n  aA -= this.m_invIA * LA;\n  cB.addMul(this.m_invMassB, P);\n  aB += this.m_invIB * LB;\n\n  this.m_bodyA.c_position.c.set(cA);\n  this.m_bodyA.c_position.a = aA;\n  this.m_bodyB.c_position.c.set(cB);\n  this.m_bodyB.c_position.a = aB;\n\n  return Math.abs(C) <= Settings.linearSlop;\n}\n","var World = require('../World');\nvar Body = require('../Body');\nvar Joint = require('../Joint');\nvar Fixture = require('../Fixture');\nvar Shape = require('../Shape');\nvar Vec2 = require('../common/Vec2');\nvar Vec3 = require('../common/Vec3');\n\nvar SID = 0;\n\nfunction Serializer(opts) {\n  opts = opts || {};\n\n  var rootClass = opts.rootClass || World;\n\n  var preSerialize = opts.preSerialize || function (obj) { return obj; };\n  var postSerialize = opts.postSerialize || function (data, obj) { return data; };\n\n  var preDeserialize = opts.preDeserialize || function (data) { return data; };\n  var postDeserialize = opts.postDeserialize || function (obj, data) { return obj; };\n\n  // This is used to create ref objects during serialize\n  var refTypes = {\n    'World': World,\n    'Body': Body,\n    'Joint': Joint,\n    'Fixture': Fixture,\n    'Shape': Shape,\n  };\n\n  // This is used by restore to deserialize objects and refs\n  var restoreTypes = Object.assign({\n    'Vec2': Vec2,\n    'Vec3': Vec3,\n  }, refTypes);\n\n  this.toJson = function (root) {\n    var json = [];\n\n    var queue = [root];\n    var refMap = {};\n\n    function storeRef(value, typeName) {\n      value.__sid = value.__sid || ++SID;\n      if (!refMap[value.__sid]) {\n        queue.push(value);\n        var index = json.length + queue.length;\n        var ref = {\n          refIndex: index,\n          refType: typeName\n        };\n        refMap[value.__sid] = ref;\n      }\n      return refMap[value.__sid];\n    }\n\n    function serialize(obj) {\n      obj = preSerialize(obj);\n      var data = obj._serialize();\n      data = postSerialize(data, obj);\n      return data;\n    }\n\n    function toJson(value, top) {\n      if (typeof value !== 'object' || value === null) {\n        return value;\n      }\n      if (typeof value._serialize === 'function') {\n        if (value !== top) {\n          for (var typeName in refTypes) {\n            if (value instanceof refTypes[typeName]) {\n              return storeRef(value, typeName);\n            }\n          }\n        }\n        value = serialize(value);\n      }\n      if (Array.isArray(value)) {\n        var newValue = [];\n        for (var key = 0; key < value.length; key++) {\n          newValue[key] = toJson(value[key]);\n        }\n        value = newValue;\n\n      } else {\n        var newValue = {};\n        for (var key in value) {\n          if (value.hasOwnProperty(key)) {\n            newValue[key] = toJson(value[key]);\n          }\n        }\n        value = newValue;\n      }\n      return value;\n    }\n\n    while (queue.length) {\n      var obj = queue.shift();\n      var str = toJson(obj, obj);\n      json.push(str);\n    }\n\n    return json;\n  };\n\n  this.fromJson = function (json) {\n    var refMap = {};\n\n    function deserialize(cls, data, ctx) {\n      data = preDeserialize(data);\n      var obj = cls._deserialize(data, ctx, restoreRef);\n      obj = postDeserialize(obj, data);\n      return obj;\n    }\n\n    function restoreRef(cls, ref, ctx) {\n      if (!ref.refIndex) {\n        return cls && cls._deserialize && deserialize(cls, ref, ctx);\n      }\n      cls = restoreTypes[ref.refType] || cls;\n      var index = ref.refIndex;\n      if (!refMap[index]) {\n        var data = json[index];\n        var obj = deserialize(cls, data, ctx);\n        refMap[index] = obj;\n      }\n      return refMap[index];\n    }\n\n    var root = rootClass._deserialize(json[0], null, restoreRef);\n\n    return root;\n  }\n}\n\nmodule.exports = Serializer;\n\nvar serializer = new Serializer();\nmodule.exports.toJson = serializer.toJson;\nmodule.exports.fromJson = serializer.fromJson;\n","/*\n * Planck.js\n * The MIT License\n * Copyright (c) 2021 Erin Catto, Ali Shakiba\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 all\n * 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 THE\n * SOFTWARE.\n */\n\nvar _DEBUG = typeof DEBUG === 'undefined' ? false : DEBUG;\nvar _ASSERT = typeof ASSERT === 'undefined' ? false : ASSERT;\n\nmodule.exports = BoxShape;\n\nvar common = require('../util/common');\nvar PolygonShape = require('./PolygonShape');\n\nBoxShape._super = PolygonShape;\nBoxShape.prototype = Object.create(BoxShape._super.prototype);\n\nBoxShape.TYPE = 'polygon';\n\n/**\n * A rectangle polygon which extend PolygonShape.\n */\nfunction BoxShape(hx, hy, center, angle) {\n  if (!(this instanceof BoxShape)) {\n    return new BoxShape(hx, hy, center, angle);\n  }\n\n  BoxShape._super.call(this);\n\n  this._setAsBox(hx, hy, center, angle);\n}\n\n","/*\n * Planck.js\n * The MIT License\n * Copyright (c) 2021 Erin Catto, Ali Shakiba\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 all\n * 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 THE\n * SOFTWARE.\n */\n\nvar _DEBUG = typeof DEBUG === 'undefined' ? false : DEBUG;\nvar _ASSERT = typeof ASSERT === 'undefined' ? false : ASSERT;\n\nmodule.exports = ChainShape;\n\nvar common = require('../util/common');\nvar options = require('../util/options');\nvar Math = require('../common/Math');\nvar Transform = require('../common/Transform');\nvar Rot = require('../common/Rot');\nvar Vec2 = require('../common/Vec2');\nvar AABB = require('../collision/AABB');\nvar Settings = require('../Settings');\nvar Shape = require('../Shape');\nvar EdgeShape = require('./EdgeShape');\n\nChainShape._super = Shape;\nChainShape.prototype = Object.create(ChainShape._super.prototype);\n\nChainShape.TYPE = 'chain';\nShape.TYPES[ChainShape.TYPE] = ChainShape;\n\n/**\n * A chain shape is a free form sequence of line segments. The chain has\n * two-sided collision, so you can use inside and outside collision. Therefore,\n * you may use any winding order. Connectivity information is used to create\n * smooth collisions.\n *\n * WARNING: The chain will not collide properly if there are self-intersections.\n */\nfunction ChainShape(vertices, loop) {\n  if (!(this instanceof ChainShape)) {\n    return new ChainShape(vertices, loop);\n  }\n\n  ChainShape._super.call(this);\n\n  this.m_type = ChainShape.TYPE;\n  this.m_radius = Settings.polygonRadius;\n  this.m_vertices = [];\n  this.m_count = 0;\n  this.m_prevVertex = null;\n  this.m_nextVertex = null;\n  this.m_hasPrevVertex = false;\n  this.m_hasNextVertex = false;\n\n  this.m_isLoop = loop;\n\n  if (vertices && vertices.length) {\n    if (loop) {\n      this._createLoop(vertices);\n    } else {\n      this._createChain(vertices);\n    }\n  }\n}\n\nChainShape.prototype._serialize = function() {\n  const data = {\n    type: this.m_type,\n    vertices: this.m_vertices,\n    isLoop: this.m_isLoop,\n    hasPrevVertex: this.m_hasPrevVertex,\n    hasNextVertex: this.m_hasNextVertex,\n  };\n  if (this.m_prevVertex) {\n    data.prevVertex = this.m_prevVertex;\n  }\n  if (this.m_nextVertex) {\n    data.nextVertex = this.m_nextVertex;\n  }\n  return data;\n};\n\nChainShape._deserialize = function(data, fixture, restore) {\n  var vertices = [];\n  if (data.vertices) {\n    for (var i = 0; i < data.vertices.length; i++) {\n      vertices.push(restore(Vec2, data.vertices[i]));\n    }\n  }\n  var shape = new ChainShape(vertices, data.isLoop);\n  if (data.prevVertex) {\n    shape.setPrevVertex(data.prevVertex);\n  }\n  if (data.nextVertex) {\n    shape.setNextVertex(data.nextVertex);\n  }\n  return shape;\n};\n\n// ChainShape.clear = function() {\n// this.m_vertices.length = 0;\n// this.m_count = 0;\n// }\n\n/**\n * Create a loop. This automatically adjusts connectivity.\n *\n * @param vertices an array of vertices, these are copied\n * @param count the vertex count\n */\nChainShape.prototype._createLoop = function(vertices) {\n  _ASSERT && common.assert(this.m_vertices.length == 0 && this.m_count == 0);\n  _ASSERT && common.assert(vertices.length >= 3);\n  for (var i = 1; i < vertices.length; ++i) {\n    var v1 = vertices[i - 1];\n    var v2 = vertices[i];\n    // If the code crashes here, it means your vertices are too close together.\n    _ASSERT && common.assert(Vec2.distanceSquared(v1, v2) > Settings.linearSlopSquared);\n  }\n\n  this.m_vertices = [];\n  this.m_count = vertices.length + 1;\n  for (var i = 0; i < vertices.length; ++i) {\n    this.m_vertices[i] = Vec2.clone(vertices[i]);\n  }\n  this.m_vertices[vertices.length] = Vec2.clone(vertices[0]);\n\n  this.m_prevVertex = this.m_vertices[this.m_count - 2];\n  this.m_nextVertex = this.m_vertices[1];\n  this.m_hasPrevVertex = true;\n  this.m_hasNextVertex = true;\n  return this;\n}\n\n/**\n * Create a chain with isolated end vertices.\n *\n * @param vertices an array of vertices, these are copied\n * @param count the vertex count\n */\nChainShape.prototype._createChain = function(vertices) {\n  _ASSERT && common.assert(this.m_vertices.length == 0 && this.m_count == 0);\n  _ASSERT && common.assert(vertices.length >= 2);\n  for (var i = 1; i < vertices.length; ++i) {\n    // If the code crashes here, it means your vertices are too close together.\n    var v1 = vertices[i - 1];\n    var v2 = vertices[i];\n    _ASSERT && common.assert(Vec2.distanceSquared(v1, v2) > Settings.linearSlopSquared);\n  }\n\n  this.m_count = vertices.length;\n  for (var i = 0; i < vertices.length; ++i) {\n    this.m_vertices[i] = Vec2.clone(vertices[i]);\n  }\n\n  this.m_hasPrevVertex = false;\n  this.m_hasNextVertex = false;\n  this.m_prevVertex = null;\n  this.m_nextVertex = null;\n  return this;\n}\n\nChainShape.prototype._reset = function() {\n  if (this.m_isLoop) {\n    this._createLoop(this.m_vertices);\n  } else {\n    this._createChain(this.m_vertices);\n  }\n}\n\n/**\n * Establish connectivity to a vertex that precedes the first vertex. Don't call\n * this for loops.\n */\nChainShape.prototype.setPrevVertex = function(prevVertex) {\n  this.m_prevVertex = prevVertex;\n  this.m_hasPrevVertex = true;\n}\n\n/**\n * Establish connectivity to a vertex that follows the last vertex. Don't call\n * this for loops.\n */\nChainShape.prototype.setNextVertex = function(nextVertex) {\n  this.m_nextVertex = nextVertex;\n  this.m_hasNextVertex = true;\n}\n\n/**\n * @deprecated\n */\nChainShape.prototype._clone = function() {\n  var clone = new ChainShape();\n  clone.createChain(this.m_vertices);\n  clone.m_type = this.m_type;\n  clone.m_radius = this.m_radius;\n  clone.m_prevVertex = this.m_prevVertex;\n  clone.m_nextVertex = this.m_nextVertex;\n  clone.m_hasPrevVertex = this.m_hasPrevVertex;\n  clone.m_hasNextVertex = this.m_hasNextVertex;\n  return clone;\n}\n\nChainShape.prototype.getChildCount = function() {\n  // edge count = vertex count - 1\n  return this.m_count - 1;\n}\n\n// Get a child edge.\nChainShape.prototype.getChildEdge = function(edge, childIndex) {\n  _ASSERT && common.assert(0 <= childIndex && childIndex < this.m_count - 1);\n  edge.m_type = EdgeShape.TYPE;\n  edge.m_radius = this.m_radius;\n\n  edge.m_vertex1 = this.m_vertices[childIndex];\n  edge.m_vertex2 = this.m_vertices[childIndex + 1];\n\n  if (childIndex > 0) {\n    edge.m_vertex0 = this.m_vertices[childIndex - 1];\n    edge.m_hasVertex0 = true;\n  } else {\n    edge.m_vertex0 = this.m_prevVertex;\n    edge.m_hasVertex0 = this.m_hasPrevVertex;\n  }\n\n  if (childIndex < this.m_count - 2) {\n    edge.m_vertex3 = this.m_vertices[childIndex + 2];\n    edge.m_hasVertex3 = true;\n  } else {\n    edge.m_vertex3 = this.m_nextVertex;\n    edge.m_hasVertex3 = this.m_hasNextVertex;\n  }\n}\n\nChainShape.prototype.getVertex = function(index) {\n  _ASSERT && common.assert(0 <= index && index <= this.m_count);\n  if (index < this.m_count) {\n    return this.m_vertices[index];\n  } else {\n    return this.m_vertices[0];\n  }\n}\n\n/**\n * This always return false.\n */\nChainShape.prototype.testPoint = function(xf, p) {\n  return false;\n}\n\nChainShape.prototype.rayCast = function(output, input, xf, childIndex) {\n  _ASSERT && common.assert(0 <= childIndex && childIndex < this.m_count);\n\n  var edgeShape = new EdgeShape(this.getVertex(childIndex), this.getVertex(childIndex + 1));\n  return edgeShape.rayCast(output, input, xf, 0);\n}\n\nChainShape.prototype.computeAABB = function(aabb, xf, childIndex) {\n  _ASSERT && common.assert(0 <= childIndex && childIndex < this.m_count);\n\n  var v1 = Transform.mulVec2(xf, this.getVertex(childIndex));\n  var v2 = Transform.mulVec2(xf, this.getVertex(childIndex + 1));\n\n  aabb.combinePoints(v1, v2);\n}\n\n/**\n * Chains have zero mass.\n */\nChainShape.prototype.computeMass = function(massData, density) {\n  massData.mass = 0.0;\n  massData.center = Vec2.neo();\n  massData.I = 0.0;\n}\n\nChainShape.prototype.computeDistanceProxy = function(proxy, childIndex) {\n  _ASSERT && common.assert(0 <= childIndex && childIndex < this.m_count);\n  proxy.m_buffer[0] = this.getVertex(childIndex);\n  proxy.m_buffer[1] = this.getVertex(childIndex + 1);\n  proxy.m_vertices = proxy.m_buffer;\n  proxy.m_count = 2;\n  proxy.m_radius = this.m_radius;\n};\n","/*\n * Planck.js\n * The MIT License\n * Copyright (c) 2021 Erin Catto, Ali Shakiba\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 all\n * 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 THE\n * SOFTWARE.\n */\n\nvar _DEBUG = typeof DEBUG === 'undefined' ? false : DEBUG;\nvar _ASSERT = typeof ASSERT === 'undefined' ? false : ASSERT;\n\nmodule.exports = CircleShape;\n\nvar common = require('../util/common');\nvar options = require('../util/options');\nvar Math = require('../common/Math');\nvar Transform = require('../common/Transform');\nvar Rot = require('../common/Rot');\nvar Vec2 = require('../common/Vec2');\nvar AABB = require('../collision/AABB');\nvar Settings = require('../Settings');\nvar Shape = require('../Shape');\n\nCircleShape._super = Shape;\nCircleShape.prototype = Object.create(CircleShape._super.prototype);\n\nCircleShape.TYPE = 'circle';\nShape.TYPES[CircleShape.TYPE] = CircleShape;\n\nfunction CircleShape(a, b) {\n  if (!(this instanceof CircleShape)) {\n    return new CircleShape(a, b);\n  }\n\n  CircleShape._super.call(this);\n\n  this.m_type = CircleShape.TYPE;\n  this.m_p = Vec2.zero();\n  this.m_radius = 1;\n\n  if (typeof a === 'object' && Vec2.isValid(a)) {\n    this.m_p.set(a);\n\n    if (typeof b === 'number') {\n      this.m_radius = b;\n    }\n\n  } else if (typeof a === 'number') {\n    this.m_radius = a;\n  }\n}\n\nCircleShape.prototype._serialize = function() {\n  return {\n    type: this.m_type,\n\n    p: this.m_p,\n    radius: this.m_radius,\n  };\n};\n\nCircleShape._deserialize = function(data) {\n  return new CircleShape(data.p, data.radius);\n};\n\nCircleShape.prototype.getRadius = function() {\n  return this.m_radius;\n}\n\nCircleShape.prototype.getCenter = function() {\n  return this.m_p;\n}\n\nCircleShape.prototype.getVertex = function(index) {\n  _ASSERT && common.assert(index == 0);\n  return this.m_p;\n}\n\nCircleShape.prototype.getVertexCount = function(index) {\n  return 1;\n}\n\n/**\n * @deprecated\n */\nCircleShape.prototype._clone = function() {\n  var clone = new CircleShape();\n  clone.m_type = this.m_type;\n  clone.m_radius = this.m_radius;\n  clone.m_p = this.m_p.clone();\n  return clone;\n}\n\nCircleShape.prototype.getChildCount = function() {\n  return 1;\n}\n\nCircleShape.prototype.testPoint = function(xf, p) {\n  var center = Vec2.add(xf.p, Rot.mulVec2(xf.q, this.m_p));\n  var d = Vec2.sub(p, center);\n  return Vec2.dot(d, d) <= this.m_radius * this.m_radius;\n}\n\n// Collision Detection in Interactive 3D Environments by Gino van den Bergen\n// From Section 3.1.2\n// x = s + a * r\n// norm(x) = radius\nCircleShape.prototype.rayCast = function(output, input, xf, childIndex) {\n\n  var position = Vec2.add(xf.p, Rot.mulVec2(xf.q, this.m_p));\n  var s = Vec2.sub(input.p1, position);\n  var b = Vec2.dot(s, s) - this.m_radius * this.m_radius;\n\n  // Solve quadratic equation.\n  var r = Vec2.sub(input.p2, input.p1);\n  var c = Vec2.dot(s, r);\n  var rr = Vec2.dot(r, r);\n  var sigma = c * c - rr * b;\n\n  // Check for negative discriminant and short segment.\n  if (sigma < 0.0 || rr < Math.EPSILON) {\n    return false;\n  }\n\n  // Find the point of intersection of the line with the circle.\n  var a = -(c + Math.sqrt(sigma));\n\n  // Is the intersection point on the segment?\n  if (0.0 <= a && a <= input.maxFraction * rr) {\n    a /= rr;\n    output.fraction = a;\n    output.normal = Vec2.add(s, Vec2.mul(a, r));\n    output.normal.normalize();\n    return true;\n  }\n\n  return false;\n}\n\nCircleShape.prototype.computeAABB = function(aabb, xf, childIndex) {\n  var p = Vec2.add(xf.p, Rot.mulVec2(xf.q, this.m_p));\n  aabb.lowerBound.set(p.x - this.m_radius, p.y - this.m_radius);\n  aabb.upperBound.set(p.x + this.m_radius, p.y + this.m_radius);\n}\n\nCircleShape.prototype.computeMass = function(massData, density) {\n  massData.mass = density * Math.PI * this.m_radius * this.m_radius;\n  massData.center = this.m_p;\n  // inertia about the local origin\n  massData.I = massData.mass\n      * (0.5 * this.m_radius * this.m_radius + Vec2.dot(this.m_p, this.m_p));\n}\n\nCircleShape.prototype.computeDistanceProxy = function(proxy) {\n  proxy.m_vertices.push(this.m_p);\n  proxy.m_count = 1;\n  proxy.m_radius = this.m_radius;\n};\n","/*\n * Planck.js\n * The MIT License\n * Copyright (c) 2021 Erin Catto, Ali Shakiba\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 all\n * 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 THE\n * SOFTWARE.\n */\n\nvar _DEBUG = typeof DEBUG === 'undefined' ? false : DEBUG;\nvar _ASSERT = typeof ASSERT === 'undefined' ? false : ASSERT;\n\nvar common = require('../util/common');\nvar Math = require('../common/Math');\nvar Transform = require('../common/Transform');\nvar Vec2 = require('../common/Vec2');\nvar Settings = require('../Settings');\nvar Shape = require('../Shape');\nvar Contact = require('../Contact');\nvar Manifold = require('../Manifold');\nvar CircleShape = require('./CircleShape');\n\nContact.addType(CircleShape.TYPE, CircleShape.TYPE, CircleCircleContact);\n\nfunction CircleCircleContact(manifold, xfA, fixtureA, indexA, xfB, fixtureB, indexB) {\n  _ASSERT && common.assert(fixtureA.getType() == CircleShape.TYPE);\n  _ASSERT && common.assert(fixtureB.getType() == CircleShape.TYPE);\n  CollideCircles(manifold, fixtureA.getShape(), xfA, fixtureB.getShape(), xfB);\n}\n\nfunction CollideCircles(manifold, circleA, xfA, circleB, xfB) {\n  manifold.pointCount = 0;\n\n  var pA = Transform.mulVec2(xfA, circleA.m_p);\n  var pB = Transform.mulVec2(xfB, circleB.m_p);\n\n  var distSqr = Vec2.distanceSquared(pB, pA);\n  var rA = circleA.m_radius;\n  var rB = circleB.m_radius;\n  var radius = rA + rB;\n  if (distSqr > radius * radius) {\n    return;\n  }\n\n  manifold.type = Manifold.e_circles;\n  manifold.localPoint.set(circleA.m_p);\n  manifold.localNormal.setZero();\n  manifold.pointCount = 1;\n  manifold.points[0].localPoint.set(circleB.m_p);\n\n  // manifold.points[0].id.key = 0;\n  manifold.points[0].id.cf.indexA = 0;\n  manifold.points[0].id.cf.typeA = Manifold.e_vertex;\n  manifold.points[0].id.cf.indexB = 0;\n  manifold.points[0].id.cf.typeB = Manifold.e_vertex;\n}\n\nexports.CollideCircles = CollideCircles;\n","/*\n * Planck.js\n * The MIT License\n * Copyright (c) 2021 Erin Catto, Ali Shakiba\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 all\n * 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 THE\n * SOFTWARE.\n */\n\nvar _DEBUG = typeof DEBUG === 'undefined' ? false : DEBUG;\nvar _ASSERT = typeof ASSERT === 'undefined' ? false : ASSERT;\n\nvar common = require('../util/common');\nvar Math = require('../common/Math');\nvar Transform = require('../common/Transform');\nvar Rot = require('../common/Rot');\nvar Vec2 = require('../common/Vec2');\nvar AABB = require('../collision/AABB');\nvar Settings = require('../Settings');\nvar Manifold = require('../Manifold');\nvar Contact = require('../Contact');\nvar Shape = require('../Shape');\nvar CircleShape = require('./CircleShape');\nvar PolygonShape = require('./PolygonShape');\n\nContact.addType(PolygonShape.TYPE, CircleShape.TYPE, PolygonCircleContact);\n\nfunction PolygonCircleContact(manifold, xfA, fixtureA, indexA, xfB, fixtureB, indexB) {\n  _ASSERT && common.assert(fixtureA.getType() == PolygonShape.TYPE);\n  _ASSERT && common.assert(fixtureB.getType() == CircleShape.TYPE);\n  CollidePolygonCircle(manifold, fixtureA.getShape(), xfA, fixtureB.getShape(),\n      xfB);\n}\n\nfunction CollidePolygonCircle(manifold, polygonA, xfA, circleB, xfB) {\n  manifold.pointCount = 0;\n\n  // Compute circle position in the frame of the polygon.\n  var c = Transform.mulVec2(xfB, circleB.m_p);\n  var cLocal = Transform.mulTVec2(xfA, c);\n\n  // Find the min separating edge.\n  var normalIndex = 0;\n  var separation = -Infinity;\n  var radius = polygonA.m_radius + circleB.m_radius;\n  var vertexCount = polygonA.m_count;\n  var vertices = polygonA.m_vertices;\n  var normals = polygonA.m_normals;\n\n  for (var i = 0; i < vertexCount; ++i) {\n    var s = Vec2.dot(normals[i], Vec2.sub(cLocal, vertices[i]));\n\n    if (s > radius) {\n      // Early out.\n      return;\n    }\n\n    if (s > separation) {\n      separation = s;\n      normalIndex = i;\n    }\n  }\n\n  // Vertices that subtend the incident face.\n  var vertIndex1 = normalIndex;\n  var vertIndex2 = vertIndex1 + 1 < vertexCount ? vertIndex1 + 1 : 0;\n  var v1 = vertices[vertIndex1];\n  var v2 = vertices[vertIndex2];\n\n  // If the center is inside the polygon ...\n  if (separation < Math.EPSILON) {\n    manifold.pointCount = 1;\n    manifold.type = Manifold.e_faceA;\n    manifold.localNormal.set(normals[normalIndex]);\n    manifold.localPoint.setCombine(0.5, v1, 0.5, v2);\n    manifold.points[0].localPoint = circleB.m_p;\n\n    // manifold.points[0].id.key = 0;\n    manifold.points[0].id.cf.indexA = 0;\n    manifold.points[0].id.cf.typeA = Manifold.e_vertex;\n    manifold.points[0].id.cf.indexB = 0;\n    manifold.points[0].id.cf.typeB = Manifold.e_vertex;\n    return;\n  }\n\n  // Compute barycentric coordinates\n  var u1 = Vec2.dot(Vec2.sub(cLocal, v1), Vec2.sub(v2, v1));\n  var u2 = Vec2.dot(Vec2.sub(cLocal, v2), Vec2.sub(v1, v2));\n  if (u1 <= 0.0) {\n    if (Vec2.distanceSquared(cLocal, v1) > radius * radius) {\n      return;\n    }\n\n    manifold.pointCount = 1;\n    manifold.type = Manifold.e_faceA;\n    manifold.localNormal.setCombine(1, cLocal, -1, v1);\n    manifold.localNormal.normalize();\n    manifold.localPoint = v1;\n    manifold.points[0].localPoint.set(circleB.m_p);\n\n    // manifold.points[0].id.key = 0;\n    manifold.points[0].id.cf.indexA = 0;\n    manifold.points[0].id.cf.typeA = Manifold.e_vertex;\n    manifold.points[0].id.cf.indexB = 0;\n    manifold.points[0].id.cf.typeB = Manifold.e_vertex;\n  } else if (u2 <= 0.0) {\n    if (Vec2.distanceSquared(cLocal, v2) > radius * radius) {\n      return;\n    }\n\n    manifold.pointCount = 1;\n    manifold.type = Manifold.e_faceA;\n    manifold.localNormal.setCombine(1, cLocal, -1, v2);\n    manifold.localNormal.normalize();\n    manifold.localPoint.set(v2);\n    manifold.points[0].localPoint.set(circleB.m_p);\n\n    // manifold.points[0].id.key = 0;\n    manifold.points[0].id.cf.indexA = 0;\n    manifold.points[0].id.cf.typeA = Manifold.e_vertex;\n    manifold.points[0].id.cf.indexB = 0;\n    manifold.points[0].id.cf.typeB = Manifold.e_vertex;\n  } else {\n    var faceCenter = Vec2.mid(v1, v2);\n    var separation = Vec2.dot(cLocal, normals[vertIndex1])\n        - Vec2.dot(faceCenter, normals[vertIndex1]);\n    if (separation > radius) {\n      return;\n    }\n\n    manifold.pointCount = 1;\n    manifold.type = Manifold.e_faceA;\n    manifold.localNormal.set(normals[vertIndex1]);\n    manifold.localPoint.set(faceCenter);\n    manifold.points[0].localPoint.set(circleB.m_p);\n\n    // manifold.points[0].id.key = 0;\n    manifold.points[0].id.cf.indexA = 0;\n    manifold.points[0].id.cf.typeA = Manifold.e_vertex;\n    manifold.points[0].id.cf.indexB = 0;\n    manifold.points[0].id.cf.typeB = Manifold.e_vertex;\n  }\n}\n","/*\n * Planck.js\n * The MIT License\n * Copyright (c) 2021 Erin Catto, Ali Shakiba\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 all\n * 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 THE\n * SOFTWARE.\n */\n\nvar _DEBUG = typeof DEBUG === 'undefined' ? false : DEBUG;\nvar _ASSERT = typeof ASSERT === 'undefined' ? false : ASSERT;\n\nvar common = require('../util/common');\nvar Math = require('../common/Math');\nvar Transform = require('../common/Transform');\nvar Vec2 = require('../common/Vec2');\nvar Rot = require('../common/Rot');\nvar Settings = require('../Settings');\nvar Shape = require('../Shape');\nvar Contact = require('../Contact');\nvar Manifold = require('../Manifold');\nvar EdgeShape = require('./EdgeShape');\nvar ChainShape = require('./ChainShape');\nvar CircleShape = require('./CircleShape');\n\nContact.addType(EdgeShape.TYPE, CircleShape.TYPE, EdgeCircleContact);\nContact.addType(ChainShape.TYPE, CircleShape.TYPE, ChainCircleContact);\n\nfunction EdgeCircleContact(manifold, xfA, fixtureA, indexA, xfB, fixtureB,\n    indexB) {\n  _ASSERT && common.assert(fixtureA.getType() == EdgeShape.TYPE);\n  _ASSERT && common.assert(fixtureB.getType() == CircleShape.TYPE);\n\n  var shapeA = fixtureA.getShape();\n  var shapeB = fixtureB.getShape();\n\n  CollideEdgeCircle(manifold, shapeA, xfA, shapeB, xfB);\n}\n\nfunction ChainCircleContact(manifold, xfA, fixtureA, indexA, xfB, fixtureB,\n    indexB) {\n  _ASSERT && common.assert(fixtureA.getType() == ChainShape.TYPE);\n  _ASSERT && common.assert(fixtureB.getType() == CircleShape.TYPE);\n\n  var chain = fixtureA.getShape();\n  var edge = new EdgeShape();\n  chain.getChildEdge(edge, indexA);\n\n  var shapeA = edge;\n  var shapeB = fixtureB.getShape();\n\n  CollideEdgeCircle(manifold, shapeA, xfA, shapeB, xfB);\n}\n\n// Compute contact points for edge versus circle.\n// This accounts for edge connectivity.\nfunction CollideEdgeCircle(manifold, edgeA, xfA, circleB, xfB) {\n  manifold.pointCount = 0;\n\n  // Compute circle in frame of edge\n  var Q = Transform.mulTVec2(xfA, Transform.mulVec2(xfB, circleB.m_p));\n\n  var A = edgeA.m_vertex1;\n  var B = edgeA.m_vertex2;\n  var e = Vec2.sub(B, A);\n\n  // Barycentric coordinates\n  var u = Vec2.dot(e, Vec2.sub(B, Q));\n  var v = Vec2.dot(e, Vec2.sub(Q, A));\n\n  var radius = edgeA.m_radius + circleB.m_radius;\n\n  // Region A\n  if (v <= 0.0) {\n    var P = Vec2.clone(A);\n    var d = Vec2.sub(Q, P);\n    var dd = Vec2.dot(d, d);\n    if (dd > radius * radius) {\n      return;\n    }\n\n    // Is there an edge connected to A?\n    if (edgeA.m_hasVertex0) {\n      var A1 = edgeA.m_vertex0;\n      var B1 = A;\n      var e1 = Vec2.sub(B1, A1);\n      var u1 = Vec2.dot(e1, Vec2.sub(B1, Q));\n\n      // Is the circle in Region AB of the previous edge?\n      if (u1 > 0.0) {\n        return;\n      }\n    }\n\n    manifold.type = Manifold.e_circles;\n    manifold.localNormal.setZero();\n    manifold.localPoint.set(P);\n    manifold.pointCount = 1;\n    manifold.points[0].localPoint.set(circleB.m_p);\n\n    // manifold.points[0].id.key = 0;\n    manifold.points[0].id.cf.indexA = 0;\n    manifold.points[0].id.cf.typeA = Manifold.e_vertex;\n    manifold.points[0].id.cf.indexB = 0;\n    manifold.points[0].id.cf.typeB = Manifold.e_vertex;\n    return;\n  }\n\n  // Region B\n  if (u <= 0.0) {\n    var P = Vec2.clone(B);\n    var d = Vec2.sub(Q, P);\n    var dd = Vec2.dot(d, d);\n    if (dd > radius * radius) {\n      return;\n    }\n\n    // Is there an edge connected to B?\n    if (edgeA.m_hasVertex3) {\n      var B2 = edgeA.m_vertex3;\n      var A2 = B;\n      var e2 = Vec2.sub(B2, A2);\n      var v2 = Vec2.dot(e2, Vec2.sub(Q, A2));\n\n      // Is the circle in Region AB of the next edge?\n      if (v2 > 0.0) {\n        return;\n      }\n    }\n\n    manifold.type = Manifold.e_circles;\n    manifold.localNormal.setZero();\n    manifold.localPoint.set(P);\n    manifold.pointCount = 1;\n    manifold.points[0].localPoint.set(circleB.m_p);\n\n    // manifold.points[0].id.key = 0;\n    manifold.points[0].id.cf.indexA = 1;\n    manifold.points[0].id.cf.typeA = Manifold.e_vertex;\n    manifold.points[0].id.cf.indexB = 0;\n    manifold.points[0].id.cf.typeB = Manifold.e_vertex;\n    return;\n  }\n\n  // Region AB\n  var den = Vec2.dot(e, e);\n  _ASSERT && common.assert(den > 0.0);\n  var P = Vec2.combine(u / den, A, v / den, B);\n  var d = Vec2.sub(Q, P);\n  var dd = Vec2.dot(d, d);\n  if (dd > radius * radius) {\n    return;\n  }\n\n  var n = Vec2.neo(-e.y, e.x);\n  if (Vec2.dot(n, Vec2.sub(Q, A)) < 0.0) {\n    n.set(-n.x, -n.y);\n  }\n  n.normalize();\n\n  manifold.type = Manifold.e_faceA;\n  manifold.localNormal = n;\n  manifold.localPoint.set(A);\n  manifold.pointCount = 1;\n  manifold.points[0].localPoint.set(circleB.m_p);\n\n  // manifold.points[0].id.key = 0;\n  manifold.points[0].id.cf.indexA = 0;\n  manifold.points[0].id.cf.typeA = Manifold.e_face;\n  manifold.points[0].id.cf.indexB = 0;\n  manifold.points[0].id.cf.typeB = Manifold.e_vertex;\n}\n","/*\n * Planck.js\n * The MIT License\n * Copyright (c) 2021 Erin Catto, Ali Shakiba\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 all\n * 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 THE\n * SOFTWARE.\n */\n\nvar _DEBUG = typeof DEBUG === 'undefined' ? false : DEBUG;\nvar _ASSERT = typeof ASSERT === 'undefined' ? false : ASSERT;\n\nvar common = require('../util/common');\nvar Math = require('../common/Math');\nvar Transform = require('../common/Transform');\nvar Vec2 = require('../common/Vec2');\nvar Rot = require('../common/Rot');\nvar Settings = require('../Settings');\nvar Shape = require('../Shape');\nvar Contact = require('../Contact');\nvar Manifold = require('../Manifold');\nvar EdgeShape = require('./EdgeShape');\nvar ChainShape = require('./ChainShape');\nvar PolygonShape = require('./PolygonShape');\n\nContact.addType(EdgeShape.TYPE, PolygonShape.TYPE, EdgePolygonContact);\nContact.addType(ChainShape.TYPE, PolygonShape.TYPE, ChainPolygonContact);\n\nfunction EdgePolygonContact(manifold, xfA, fA, indexA, xfB, fB, indexB) {\n  _ASSERT && common.assert(fA.getType() == EdgeShape.TYPE);\n  _ASSERT && common.assert(fB.getType() == PolygonShape.TYPE);\n\n  CollideEdgePolygon(manifold, fA.getShape(), xfA, fB.getShape(), xfB);\n}\n\nfunction ChainPolygonContact(manifold, xfA, fA, indexA, xfB, fB, indexB) {\n  _ASSERT && common.assert(fA.getType() == ChainShape.TYPE);\n  _ASSERT && common.assert(fB.getType() == PolygonShape.TYPE);\n\n  var chain = fA.getShape();\n  var edge = new EdgeShape();\n  chain.getChildEdge(edge, indexA);\n\n  CollideEdgePolygon(manifold, edge, xfA, fB.getShape(), xfB);\n}\n\n// EPAxis Type\nvar e_unknown = -1;\nvar e_edgeA = 1;\nvar e_edgeB = 2;\n\n// VertexType unused?\nvar e_isolated = 0;\nvar e_concave = 1;\nvar e_convex = 2;\n\n// This structure is used to keep track of the best separating axis.\nfunction EPAxis() {\n  this.type; // Type\n  this.index;\n  this.separation;\n};\n\n// This holds polygon B expressed in frame A.\nfunction TempPolygon() {\n  this.vertices = []; // Vec2[Settings.maxPolygonVertices]\n  this.normals = []; // Vec2[Settings.maxPolygonVertices];\n  this.count = 0;\n};\n\n// Reference face used for clipping\nfunction ReferenceFace() {\n  this.i1, this.i2; // int\n  this.v1, this.v2; // v\n  this.normal = Vec2.zero();\n  this.sideNormal1 = Vec2.zero();\n  this.sideOffset1; // float\n  this.sideNormal2 = Vec2.zero();\n  this.sideOffset2; // float\n};\n\n// reused\nvar edgeAxis = new EPAxis();\nvar polygonAxis = new EPAxis();\nvar polygonBA = new TempPolygon();\nvar rf = new ReferenceFace();\n\n/**\n * This function collides and edge and a polygon, taking into account edge\n * adjacency.\n */\nfunction CollideEdgePolygon(manifold, edgeA, xfA, polygonB, xfB) {\n  // Algorithm:\n  // 1. Classify v1 and v2\n  // 2. Classify polygon centroid as front or back\n  // 3. Flip normal if necessary\n  // 4. Initialize normal range to [-pi, pi] about face normal\n  // 5. Adjust normal range according to adjacent edges\n  // 6. Visit each separating axes, only accept axes within the range\n  // 7. Return if _any_ axis indicates separation\n  // 8. Clip\n\n  var m_type1, m_type2; // VertexType unused?\n\n  var xf = Transform.mulTXf(xfA, xfB);\n\n  var centroidB = Transform.mulVec2(xf, polygonB.m_centroid);\n\n  var v0 = edgeA.m_vertex0;\n  var v1 = edgeA.m_vertex1;\n  var v2 = edgeA.m_vertex2;\n  var v3 = edgeA.m_vertex3;\n\n  var hasVertex0 = edgeA.m_hasVertex0;\n  var hasVertex3 = edgeA.m_hasVertex3;\n\n  var edge1 = Vec2.sub(v2, v1);\n  edge1.normalize();\n  var normal1 = Vec2.neo(edge1.y, -edge1.x);\n  var offset1 = Vec2.dot(normal1, Vec2.sub(centroidB, v1));\n  var offset0 = 0.0;\n  var offset2 = 0.0;\n  var convex1 = false;\n  var convex2 = false;\n\n  // Is there a preceding edge?\n  if (hasVertex0) {\n    var edge0 = Vec2.sub(v1, v0);\n    edge0.normalize();\n    var normal0 = Vec2.neo(edge0.y, -edge0.x);\n    convex1 = Vec2.cross(edge0, edge1) >= 0.0;\n    offset0 = Vec2.dot(normal0, centroidB) - Vec2.dot(normal0, v0);\n  }\n\n  // Is there a following edge?\n  if (hasVertex3) {\n    var edge2 = Vec2.sub(v3, v2);\n    edge2.normalize();\n    var normal2 = Vec2.neo(edge2.y, -edge2.x);\n    convex2 = Vec2.cross(edge1, edge2) > 0.0;\n    offset2 = Vec2.dot(normal2, centroidB) - Vec2.dot(normal2, v2);\n  }\n\n  var front;\n  var normal = Vec2.zero();\n  var lowerLimit = Vec2.zero();\n  var upperLimit = Vec2.zero();\n\n  // Determine front or back collision. Determine collision normal limits.\n  if (hasVertex0 && hasVertex3) {\n    if (convex1 && convex2) {\n      front = offset0 >= 0.0 || offset1 >= 0.0 || offset2 >= 0.0;\n      if (front) {\n        normal.set(normal1);\n        lowerLimit.set(normal0);\n        upperLimit.set(normal2);\n      } else {\n        normal.setMul(-1, normal1);\n        lowerLimit.setMul(-1, normal1);\n        upperLimit.setMul(-1, normal1);\n      }\n    } else if (convex1) {\n      front = offset0 >= 0.0 || (offset1 >= 0.0 && offset2 >= 0.0);\n      if (front) {\n        normal.set(normal1);\n        lowerLimit.set(normal0);\n        upperLimit.set(normal1);\n      } else {\n        normal.setMul(-1, normal1);\n        lowerLimit.setMul(-1, normal2);\n        upperLimit.setMul(-1, normal1);\n      }\n    } else if (convex2) {\n      front = offset2 >= 0.0 || (offset0 >= 0.0 && offset1 >= 0.0);\n      if (front) {\n        normal.set(normal1);\n        lowerLimit.set(normal1);\n        upperLimit.set(normal2);\n      } else {\n        normal.setMul(-1, normal1);\n        lowerLimit.setMul(-1, normal1);\n        upperLimit.setMul(-1, normal0);\n      }\n    } else {\n      front = offset0 >= 0.0 && offset1 >= 0.0 && offset2 >= 0.0;\n      if (front) {\n        normal.set(normal1);\n        lowerLimit.set(normal1);\n        upperLimit.set(normal1);\n      } else {\n        normal.setMul(-1, normal1);\n        lowerLimit.setMul(-1, normal2);\n        upperLimit.setMul(-1, normal0);\n      }\n    }\n  } else if (hasVertex0) {\n    if (convex1) {\n      front = offset0 >= 0.0 || offset1 >= 0.0;\n      if (front) {\n        normal.set(normal1);\n        lowerLimit.set(normal0);\n        upperLimit.setMul(-1, normal1);\n      } else {\n        normal.setMul(-1, normal1);\n        lowerLimit.set(normal1);\n        upperLimit.setMul(-1, normal1);\n      }\n    } else {\n      front = offset0 >= 0.0 && offset1 >= 0.0;\n      if (front) {\n        normal.set(normal1);\n        lowerLimit.set(normal1);\n        upperLimit.setMul(-1, normal1);\n      } else {\n        normal.setMul(-1, normal1);\n        lowerLimit.set(normal1);\n        upperLimit.setMul(-1, normal0);\n      }\n    }\n  } else if (hasVertex3) {\n    if (convex2) {\n      front = offset1 >= 0.0 || offset2 >= 0.0;\n      if (front) {\n        normal.set(normal1);\n        lowerLimit.setMul(-1, normal1);\n        upperLimit.set(normal2);\n      } else {\n        normal.setMul(-1, normal1);\n        lowerLimit.setMul(-1, normal1);\n        upperLimit.set(normal1);\n      }\n    } else {\n      front = offset1 >= 0.0 && offset2 >= 0.0;\n      if (front) {\n        normal.set(normal1);\n        lowerLimit.setMul(-1, normal1);\n        upperLimit.set(normal1);\n      } else {\n        normal.setMul(-1, normal1);\n        lowerLimit.setMul(-1, normal2);\n        upperLimit.set(normal1);\n      }\n    }\n  } else {\n    front = offset1 >= 0.0;\n    if (front) {\n      normal.set(normal1);\n      lowerLimit.setMul(-1, normal1);\n      upperLimit.setMul(-1, normal1);\n    } else {\n      normal.setMul(-1, normal1);\n      lowerLimit.set(normal1);\n      upperLimit.set(normal1);\n    }\n  }\n\n  // Get polygonB in frameA\n  polygonBA.count = polygonB.m_count;\n  for (var i = 0; i < polygonB.m_count; ++i) {\n    polygonBA.vertices[i] = Transform.mulVec2(xf, polygonB.m_vertices[i]);\n    polygonBA.normals[i] = Rot.mulVec2(xf.q, polygonB.m_normals[i]);\n  }\n\n  var radius = 2.0 * Settings.polygonRadius;\n\n  manifold.pointCount = 0;\n\n  { // ComputeEdgeSeparation\n    edgeAxis.type = e_edgeA;\n    edgeAxis.index = front ? 0 : 1;\n    edgeAxis.separation = Infinity;\n\n    for (var i = 0; i < polygonBA.count; ++i) {\n      var s = Vec2.dot(normal, Vec2.sub(polygonBA.vertices[i], v1));\n      if (s < edgeAxis.separation) {\n        edgeAxis.separation = s;\n      }\n    }\n  }\n\n  // If no valid normal can be found than this edge should not collide.\n  if (edgeAxis.type == e_unknown) {\n    return;\n  }\n\n  if (edgeAxis.separation > radius) {\n    return;\n  }\n\n  { // ComputePolygonSeparation\n    polygonAxis.type = e_unknown;\n    polygonAxis.index = -1;\n    polygonAxis.separation = -Infinity;\n\n    var perp = Vec2.neo(-normal.y, normal.x);\n\n    for (var i = 0; i < polygonBA.count; ++i) {\n      var n = Vec2.neg(polygonBA.normals[i]);\n\n      var s1 = Vec2.dot(n, Vec2.sub(polygonBA.vertices[i], v1));\n      var s2 = Vec2.dot(n, Vec2.sub(polygonBA.vertices[i], v2));\n      var s = Math.min(s1, s2);\n\n      if (s > radius) {\n        // No collision\n        polygonAxis.type = e_edgeB;\n        polygonAxis.index = i;\n        polygonAxis.separation = s;\n        break;\n      }\n\n      // Adjacency\n      if (Vec2.dot(n, perp) >= 0.0) {\n        if (Vec2.dot(Vec2.sub(n, upperLimit), normal) < -Settings.angularSlop) {\n          continue;\n        }\n      } else {\n        if (Vec2.dot(Vec2.sub(n, lowerLimit), normal) < -Settings.angularSlop) {\n          continue;\n        }\n      }\n\n      if (s > polygonAxis.separation) {\n        polygonAxis.type = e_edgeB;\n        polygonAxis.index = i;\n        polygonAxis.separation = s;\n      }\n    }\n  }\n\n  if (polygonAxis.type != e_unknown && polygonAxis.separation > radius) {\n    return;\n  }\n\n  // Use hysteresis for jitter reduction.\n  var k_relativeTol = 0.98;\n  var k_absoluteTol = 0.001;\n\n  var primaryAxis;\n  if (polygonAxis.type == e_unknown) {\n    primaryAxis = edgeAxis;\n  } else if (polygonAxis.separation > k_relativeTol * edgeAxis.separation + k_absoluteTol) {\n    primaryAxis = polygonAxis;\n  } else {\n    primaryAxis = edgeAxis;\n  }\n\n  var ie = [ new Manifold.clipVertex(), new Manifold.clipVertex() ];\n\n  if (primaryAxis.type == e_edgeA) {\n    manifold.type = Manifold.e_faceA;\n\n    // Search for the polygon normal that is most anti-parallel to the edge\n    // normal.\n    var bestIndex = 0;\n    var bestValue = Vec2.dot(normal, polygonBA.normals[0]);\n    for (var i = 1; i < polygonBA.count; ++i) {\n      var value = Vec2.dot(normal, polygonBA.normals[i]);\n      if (value < bestValue) {\n        bestValue = value;\n        bestIndex = i;\n      }\n    }\n\n    var i1 = bestIndex;\n    var i2 = i1 + 1 < polygonBA.count ? i1 + 1 : 0;\n\n    ie[0].v = polygonBA.vertices[i1];\n    ie[0].id.cf.indexA = 0;\n    ie[0].id.cf.indexB = i1;\n    ie[0].id.cf.typeA = Manifold.e_face;\n    ie[0].id.cf.typeB = Manifold.e_vertex;\n\n    ie[1].v = polygonBA.vertices[i2];\n    ie[1].id.cf.indexA = 0;\n    ie[1].id.cf.indexB = i2;\n    ie[1].id.cf.typeA = Manifold.e_face;\n    ie[1].id.cf.typeB = Manifold.e_vertex;\n\n    if (front) {\n      rf.i1 = 0;\n      rf.i2 = 1;\n      rf.v1 = v1;\n      rf.v2 = v2;\n      rf.normal.set(normal1);\n    } else {\n      rf.i1 = 1;\n      rf.i2 = 0;\n      rf.v1 = v2;\n      rf.v2 = v1;\n      rf.normal.setMul(-1, normal1);\n    }\n  } else {\n    manifold.type = Manifold.e_faceB;\n\n    ie[0].v = v1;\n    ie[0].id.cf.indexA = 0;\n    ie[0].id.cf.indexB = primaryAxis.index;\n    ie[0].id.cf.typeA = Manifold.e_vertex;\n    ie[0].id.cf.typeB = Manifold.e_face;\n\n    ie[1].v = v2;\n    ie[1].id.cf.indexA = 0;\n    ie[1].id.cf.indexB = primaryAxis.index;\n    ie[1].id.cf.typeA = Manifold.e_vertex;\n    ie[1].id.cf.typeB = Manifold.e_face;\n\n    rf.i1 = primaryAxis.index;\n    rf.i2 = rf.i1 + 1 < polygonBA.count ? rf.i1 + 1 : 0;\n    rf.v1 = polygonBA.vertices[rf.i1];\n    rf.v2 = polygonBA.vertices[rf.i2];\n    rf.normal.set(polygonBA.normals[rf.i1]);\n  }\n\n  rf.sideNormal1.set(rf.normal.y, -rf.normal.x);\n  rf.sideNormal2.setMul(-1, rf.sideNormal1);\n  rf.sideOffset1 = Vec2.dot(rf.sideNormal1, rf.v1);\n  rf.sideOffset2 = Vec2.dot(rf.sideNormal2, rf.v2);\n\n  // Clip incident edge against extruded edge1 side edges.\n  var clipPoints1 = [ new Manifold.clipVertex(), new Manifold.clipVertex() ];\n  var clipPoints2 = [ new Manifold.clipVertex(), new Manifold.clipVertex() ];\n\n  var np;\n\n  // Clip to box side 1\n  np = Manifold.clipSegmentToLine(clipPoints1, ie, rf.sideNormal1, rf.sideOffset1, rf.i1);\n\n  if (np < Settings.maxManifoldPoints) {\n    return;\n  }\n\n  // Clip to negative box side 1\n  np = Manifold.clipSegmentToLine(clipPoints2, clipPoints1, rf.sideNormal2, rf.sideOffset2, rf.i2);\n\n  if (np < Settings.maxManifoldPoints) {\n    return;\n  }\n\n  // Now clipPoints2 contains the clipped points.\n  if (primaryAxis.type == e_edgeA) {\n    manifold.localNormal = Vec2.clone(rf.normal);\n    manifold.localPoint = Vec2.clone(rf.v1);\n  } else {\n    manifold.localNormal = Vec2.clone(polygonB.m_normals[rf.i1]);\n    manifold.localPoint = Vec2.clone(polygonB.m_vertices[rf.i1]);\n  }\n\n  var pointCount = 0;\n  for (var i = 0; i < Settings.maxManifoldPoints; ++i) {\n    var separation = Vec2.dot(rf.normal, Vec2.sub(clipPoints2[i].v, rf.v1));\n\n    if (separation <= radius) {\n      var cp = manifold.points[pointCount]; // ManifoldPoint\n\n      if (primaryAxis.type == e_edgeA) {\n        cp.localPoint = Transform.mulT(xf, clipPoints2[i].v);\n        cp.id = clipPoints2[i].id;\n      } else {\n        cp.localPoint = clipPoints2[i].v;\n        cp.id.cf.typeA = clipPoints2[i].id.cf.typeB;\n        cp.id.cf.typeB = clipPoints2[i].id.cf.typeA;\n        cp.id.cf.indexA = clipPoints2[i].id.cf.indexB;\n        cp.id.cf.indexB = clipPoints2[i].id.cf.indexA;\n      }\n\n      ++pointCount;\n    }\n  }\n\n  manifold.pointCount = pointCount;\n}\n","/*\n * Planck.js\n * The MIT License\n * Copyright (c) 2021 Erin Catto, Ali Shakiba\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 all\n * 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 THE\n * SOFTWARE.\n */\n\nvar _DEBUG = typeof DEBUG === 'undefined' ? false : DEBUG;\nvar _ASSERT = typeof ASSERT === 'undefined' ? false : ASSERT;\n\nvar common = require('../util/common');\nvar Math = require('../common/Math');\nvar Transform = require('../common/Transform');\nvar Rot = require('../common/Rot');\nvar Vec2 = require('../common/Vec2');\nvar AABB = require('../collision/AABB');\nvar Settings = require('../Settings');\nvar Manifold = require('../Manifold');\nvar Contact = require('../Contact');\nvar Shape = require('../Shape');\nvar PolygonShape = require('./PolygonShape');\n\nmodule.exports = CollidePolygons;\n\nContact.addType(PolygonShape.TYPE, PolygonShape.TYPE, PolygonContact);\n\nfunction PolygonContact(manifold, xfA, fixtureA, indexA, xfB, fixtureB, indexB) {\n  _ASSERT && common.assert(fixtureA.getType() == PolygonShape.TYPE);\n  _ASSERT && common.assert(fixtureB.getType() == PolygonShape.TYPE);\n  CollidePolygons(manifold, fixtureA.getShape(), xfA, fixtureB.getShape(), xfB);\n}\n\n/**\n * Find the max separation between poly1 and poly2 using edge normals from\n * poly1.\n */\nfunction FindMaxSeparation(poly1, xf1, poly2, xf2) {\n  var count1 = poly1.m_count;\n  var count2 = poly2.m_count;\n  var n1s = poly1.m_normals;\n  var v1s = poly1.m_vertices;\n  var v2s = poly2.m_vertices;\n  var xf = Transform.mulTXf(xf2, xf1);\n\n  var bestIndex = 0;\n  var maxSeparation = -Infinity;\n  for (var i = 0; i < count1; ++i) {\n    // Get poly1 normal in frame2.\n    var n = Rot.mulVec2(xf.q, n1s[i]);\n    var v1 = Transform.mulVec2(xf, v1s[i]);\n\n    // Find deepest point for normal i.\n    var si = Infinity;\n    for (var j = 0; j < count2; ++j) {\n      var sij = Vec2.dot(n, v2s[j]) - Vec2.dot(n, v1);\n      if (sij < si) {\n        si = sij;\n      }\n    }\n\n    if (si > maxSeparation) {\n      maxSeparation = si;\n      bestIndex = i;\n    }\n  }\n\n  // used to keep last FindMaxSeparation call values\n  FindMaxSeparation._maxSeparation = maxSeparation;\n  FindMaxSeparation._bestIndex = bestIndex;\n}\n\n/**\n * @param {ClipVertex[2]} c\n * @param {int} edge1\n */\nfunction FindIncidentEdge(c, poly1, xf1, edge1, poly2, xf2) {\n  var normals1 = poly1.m_normals;\n\n  var count2 = poly2.m_count;\n  var vertices2 = poly2.m_vertices;\n  var normals2 = poly2.m_normals;\n\n  _ASSERT && common.assert(0 <= edge1 && edge1 < poly1.m_count);\n\n  // Get the normal of the reference edge in poly2's frame.\n  var normal1 = Rot.mulT(xf2.q, Rot.mulVec2(xf1.q, normals1[edge1]));\n\n  // Find the incident edge on poly2.\n  var index = 0;\n  var minDot = Infinity;\n  for (var i = 0; i < count2; ++i) {\n    var dot = Vec2.dot(normal1, normals2[i]);\n    if (dot < minDot) {\n      minDot = dot;\n      index = i;\n    }\n  }\n\n  // Build the clip vertices for the incident edge.\n  var i1 = index;\n  var i2 = i1 + 1 < count2 ? i1 + 1 : 0;\n\n  c[0].v = Transform.mulVec2(xf2, vertices2[i1]);\n  c[0].id.cf.indexA = edge1;\n  c[0].id.cf.indexB = i1;\n  c[0].id.cf.typeA = Manifold.e_face;\n  c[0].id.cf.typeB = Manifold.e_vertex;\n\n  c[1].v = Transform.mulVec2(xf2, vertices2[i2]);\n  c[1].id.cf.indexA = edge1;\n  c[1].id.cf.indexB = i2;\n  c[1].id.cf.typeA = Manifold.e_face;\n  c[1].id.cf.typeB = Manifold.e_vertex;\n}\n\n/**\n * \n * Find edge normal of max separation on A - return if separating axis is found<br>\n * Find edge normal of max separation on B - return if separation axis is found<br>\n * Choose reference edge as min(minA, minB)<br>\n * Find incident edge<br>\n * Clip\n * \n * The normal points from 1 to 2\n */\nfunction CollidePolygons(manifold, polyA, xfA, polyB, xfB) {\n  manifold.pointCount = 0;\n  var totalRadius = polyA.m_radius + polyB.m_radius;\n\n  FindMaxSeparation(polyA, xfA, polyB, xfB);\n  var edgeA = FindMaxSeparation._bestIndex;\n  var separationA = FindMaxSeparation._maxSeparation;\n  if (separationA > totalRadius)\n    return;\n\n  FindMaxSeparation(polyB, xfB, polyA, xfA);\n  var edgeB = FindMaxSeparation._bestIndex;\n  var separationB = FindMaxSeparation._maxSeparation;\n  if (separationB > totalRadius)\n    return;\n\n  var poly1; // reference polygon\n  var poly2; // incident polygon\n  var xf1;\n  var xf2;\n  var edge1; // reference edge\n  var flip;\n  var k_tol = 0.1 * Settings.linearSlop;\n\n  if (separationB > separationA + k_tol) {\n    poly1 = polyB;\n    poly2 = polyA;\n    xf1 = xfB;\n    xf2 = xfA;\n    edge1 = edgeB;\n    manifold.type = Manifold.e_faceB;\n    flip = 1;\n  } else {\n    poly1 = polyA;\n    poly2 = polyB;\n    xf1 = xfA;\n    xf2 = xfB;\n    edge1 = edgeA;\n    manifold.type = Manifold.e_faceA;\n    flip = 0;\n  }\n\n  var incidentEdge = [ new Manifold.clipVertex(), new Manifold.clipVertex() ];\n  FindIncidentEdge(incidentEdge, poly1, xf1, edge1, poly2, xf2);\n\n  var count1 = poly1.m_count;\n  var vertices1 = poly1.m_vertices;\n\n  var iv1 = edge1;\n  var iv2 = edge1 + 1 < count1 ? edge1 + 1 : 0;\n\n  var v11 = vertices1[iv1];\n  var v12 = vertices1[iv2];\n\n  var localTangent = Vec2.sub(v12, v11);\n  localTangent.normalize();\n\n  var localNormal = Vec2.cross(localTangent, 1.0);\n  var planePoint = Vec2.combine(0.5, v11, 0.5, v12);\n\n  var tangent = Rot.mulVec2(xf1.q, localTangent);\n  var normal = Vec2.cross(tangent, 1.0);\n\n  v11 = Transform.mulVec2(xf1, v11);\n  v12 = Transform.mulVec2(xf1, v12);\n\n  // Face offset.\n  var frontOffset = Vec2.dot(normal, v11);\n\n  // Side offsets, extended by polytope skin thickness.\n  var sideOffset1 = -Vec2.dot(tangent, v11) + totalRadius;\n  var sideOffset2 = Vec2.dot(tangent, v12) + totalRadius;\n\n  // Clip incident edge against extruded edge1 side edges.\n  var clipPoints1 = [ new Manifold.clipVertex(), new Manifold.clipVertex() ];\n  var clipPoints2 = [ new Manifold.clipVertex(), new Manifold.clipVertex() ];\n  var np;\n\n  // Clip to box side 1\n  np = Manifold.clipSegmentToLine(clipPoints1, incidentEdge, Vec2.neg(tangent),\n      sideOffset1, iv1);\n\n  if (np < 2) {\n    return;\n  }\n\n  // Clip to negative box side 1\n  np = Manifold.clipSegmentToLine(clipPoints2, clipPoints1, tangent,\n      sideOffset2, iv2);\n\n  if (np < 2) {\n    return;\n  }\n\n  // Now clipPoints2 contains the clipped points.\n  manifold.localNormal = localNormal;\n  manifold.localPoint = planePoint;\n\n  var pointCount = 0;\n  for (var i = 0; i < clipPoints2.length/* maxManifoldPoints */; ++i) {\n    var separation = Vec2.dot(normal, clipPoints2[i].v) - frontOffset;\n\n    if (separation <= totalRadius) {\n      var cp = manifold.points[pointCount]; // ManifoldPoint\n      cp.localPoint.set(Transform.mulTVec2(xf2, clipPoints2[i].v));\n      cp.id = clipPoints2[i].id;\n      if (flip) {\n        // Swap features\n        var cf = cp.id.cf; // ContactFeature\n        var indexA = cf.indexA;\n        var indexB = cf.indexB;\n        var typeA = cf.typeA;\n        var typeB = cf.typeB;\n        cf.indexA = indexB;\n        cf.indexB = indexA;\n        cf.typeA = typeB;\n        cf.typeB = typeA;\n      }\n      ++pointCount;\n    }\n  }\n\n  manifold.pointCount = pointCount;\n}\n","/*\n * Planck.js\n * The MIT License\n * Copyright (c) 2021 Erin Catto, Ali Shakiba\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 all\n * 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 THE\n * SOFTWARE.\n */\n\nvar _DEBUG = typeof DEBUG === 'undefined' ? false : DEBUG;\nvar _ASSERT = typeof ASSERT === 'undefined' ? false : ASSERT;\n\nmodule.exports = EdgeShape;\n\nvar options = require('../util/options');\nvar Settings = require('../Settings');\nvar Shape = require('../Shape');\nvar Math = require('../common/Math');\nvar Transform = require('../common/Transform');\nvar Rot = require('../common/Rot');\nvar Vec2 = require('../common/Vec2');\nvar AABB = require('../collision/AABB');\n\nEdgeShape._super = Shape;\nEdgeShape.prototype = Object.create(EdgeShape._super.prototype);\n\nEdgeShape.TYPE = 'edge';\nShape.TYPES[EdgeShape.TYPE] = EdgeShape;\n\n/**\n * A line segment (edge) shape. These can be connected in chains or loops to\n * other edge shapes. The connectivity information is used to ensure correct\n * contact normals.\n */\nfunction EdgeShape(v1, v2) {\n  if (!(this instanceof EdgeShape)) {\n    return new EdgeShape(v1, v2);\n  }\n\n  EdgeShape._super.call(this);\n\n  this.m_type = EdgeShape.TYPE;\n  this.m_radius = Settings.polygonRadius;\n\n  // These are the edge vertices\n  this.m_vertex1 = v1 ? Vec2.clone(v1) : Vec2.zero();\n  this.m_vertex2 = v2 ? Vec2.clone(v2) : Vec2.zero();\n\n  // Optional adjacent vertices. These are used for smooth collision.\n  // Used by chain shape.\n  this.m_vertex0 = Vec2.zero();\n  this.m_vertex3 = Vec2.zero();\n  this.m_hasVertex0 = false;\n  this.m_hasVertex3 = false;\n}\n\nEdgeShape.prototype._serialize = function() {\n  return {\n    type: this.m_type,\n\n    vertex1: this.m_vertex1,\n    vertex2: this.m_vertex2,\n\n    vertex0: this.m_vertex0,\n    vertex3: this.m_vertex3,\n    hasVertex0: this.m_hasVertex0,\n    hasVertex3: this.m_hasVertex3,\n  };\n};\n\nEdgeShape._deserialize = function(data) {\n  var shape = new EdgeShape(data.vertex1, data.vertex2);\n  if (shape.hasVertex0) {\n    shape.setPrev(data.vertex0);\n  }\n  if (shape.hasVertex3) {\n    shape.setNext(data.vertex3);\n  }\n  return shape;\n};\n\nEdgeShape.prototype.setNext = function(v3) {\n  if (v3) {\n    this.m_vertex3.set(v3);\n    this.m_hasVertex3 = true;\n  } else {\n    this.m_vertex3.setZero();\n    this.m_hasVertex3 = false;\n  }\n  return this;\n};\n\nEdgeShape.prototype.setPrev = function(v0) {\n  if (v0) {\n    this.m_vertex0.set(v0);\n    this.m_hasVertex0 = true;\n  } else {\n    this.m_vertex0.setZero();\n    this.m_hasVertex0 = false;\n  }\n  return this;\n};\n\n/**\n * Set this as an isolated edge.\n */\nEdgeShape.prototype._set = function(v1, v2) {\n  this.m_vertex1.set(v1);\n  this.m_vertex2.set(v2);\n  this.m_hasVertex0 = false;\n  this.m_hasVertex3 = false;\n  return this;\n}\n\n/**\n * @deprecated\n */\nEdgeShape.prototype._clone = function() {\n  var clone = new EdgeShape();\n  clone.m_type = this.m_type;\n  clone.m_radius = this.m_radius;\n  clone.m_vertex1.set(this.m_vertex1);\n  clone.m_vertex2.set(this.m_vertex2);\n  clone.m_vertex0.set(this.m_vertex0);\n  clone.m_vertex3.set(this.m_vertex3);\n  clone.m_hasVertex0 = this.m_hasVertex0;\n  clone.m_hasVertex3 = this.m_hasVertex3;\n  return clone;\n}\n\nEdgeShape.prototype.getChildCount = function() {\n  return 1;\n}\n\nEdgeShape.prototype.testPoint = function(xf, p) {\n  return false;\n}\n\n// p = p1 + t * d\n// v = v1 + s * e\n// p1 + t * d = v1 + s * e\n// s * e - t * d = p1 - v1\nEdgeShape.prototype.rayCast = function(output, input, xf, childIndex) {\n  // NOT_USED(childIndex);\n\n  // Put the ray into the edge's frame of reference.\n  var p1 = Rot.mulTVec2(xf.q, Vec2.sub(input.p1, xf.p));\n  var p2 = Rot.mulTVec2(xf.q, Vec2.sub(input.p2, xf.p));\n  var d = Vec2.sub(p2, p1);\n\n  var v1 = this.m_vertex1;\n  var v2 = this.m_vertex2;\n  var e = Vec2.sub(v2, v1);\n  var normal = Vec2.neo(e.y, -e.x);\n  normal.normalize();\n\n  // q = p1 + t * d\n  // dot(normal, q - v1) = 0\n  // dot(normal, p1 - v1) + t * dot(normal, d) = 0\n  var numerator = Vec2.dot(normal, Vec2.sub(v1, p1));\n  var denominator = Vec2.dot(normal, d);\n\n  if (denominator == 0.0) {\n    return false;\n  }\n\n  var t = numerator / denominator;\n  if (t < 0.0 || input.maxFraction < t) {\n    return false;\n  }\n\n  var q = Vec2.add(p1, Vec2.mul(t, d));\n\n  // q = v1 + s * r\n  // s = dot(q - v1, r) / dot(r, r)\n  var r = Vec2.sub(v2, v1);\n  var rr = Vec2.dot(r, r);\n  if (rr == 0.0) {\n    return false;\n  }\n\n  var s = Vec2.dot(Vec2.sub(q, v1), r) / rr;\n  if (s < 0.0 || 1.0 < s) {\n    return false;\n  }\n\n  output.fraction = t;\n  if (numerator > 0.0) {\n    output.normal = Rot.mulVec2(xf.q, normal).neg();\n  } else {\n    output.normal = Rot.mulVec2(xf.q, normal);\n  }\n  return true;\n}\n\nEdgeShape.prototype.computeAABB = function(aabb, xf, childIndex) {\n  var v1 = Transform.mulVec2(xf, this.m_vertex1);\n  var v2 = Transform.mulVec2(xf, this.m_vertex2);\n\n  aabb.combinePoints(v1, v2);\n  aabb.extend(this.m_radius)\n}\n\nEdgeShape.prototype.computeMass = function(massData, density) {\n  massData.mass = 0.0;\n  massData.center.setCombine(0.5, this.m_vertex1, 0.5, this.m_vertex2);\n  massData.I = 0.0;\n}\n\nEdgeShape.prototype.computeDistanceProxy = function(proxy) {\n  proxy.m_vertices.push(this.m_vertex1);\n  proxy.m_vertices.push(this.m_vertex2);\n  proxy.m_count = 2;\n  proxy.m_radius = this.m_radius;\n};\n","/*\n * Planck.js\n * The MIT License\n * Copyright (c) 2021 Erin Catto, Ali Shakiba\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 all\n * 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 THE\n * SOFTWARE.\n */\n\nvar _DEBUG = typeof DEBUG === 'undefined' ? false : DEBUG;\nvar _ASSERT = typeof ASSERT === 'undefined' ? false : ASSERT;\n\nmodule.exports = PolygonShape;\n\nvar common = require('../util/common');\nvar options = require('../util/options');\nvar Math = require('../common/Math');\nvar Transform = require('../common/Transform');\nvar Rot = require('../common/Rot');\nvar Vec2 = require('../common/Vec2');\nvar AABB = require('../collision/AABB');\nvar Settings = require('../Settings');\nvar Shape = require('../Shape');\n\nPolygonShape._super = Shape;\nPolygonShape.prototype = Object.create(PolygonShape._super.prototype);\n\nPolygonShape.TYPE = 'polygon';\nShape.TYPES[PolygonShape.TYPE] = PolygonShape;\n\n/**\n * A convex polygon. It is assumed that the interior of the polygon is to the\n * left of each edge. Polygons have a maximum number of vertices equal to\n * Settings.maxPolygonVertices. In most cases you should not need many vertices\n * for a convex polygon. extends Shape\n */\nfunction PolygonShape(vertices) {\n  if (!(this instanceof PolygonShape)) {\n    return new PolygonShape(vertices);\n  }\n\n  PolygonShape._super.call(this);\n\n  this.m_type = PolygonShape.TYPE;\n  this.m_radius = Settings.polygonRadius;\n  this.m_centroid = Vec2.zero();\n  this.m_vertices = []; // Vec2[Settings.maxPolygonVertices]\n  this.m_normals = []; // Vec2[Settings.maxPolygonVertices]\n  this.m_count = 0;\n\n  if (vertices && vertices.length) {\n    this._set(vertices);\n  }\n}\n\nPolygonShape.prototype._serialize = function() {\n  return {\n    type: this.m_type,\n\n    vertices: this.m_vertices,\n  };\n};\n\nPolygonShape._deserialize = function(data, fixture, restore) {\n  var vertices = [];\n  if (data.vertices) {\n    for (var i = 0; i < data.vertices.length; i++) {\n      vertices.push(restore(Vec2, data.vertices[i]));\n    }\n  }\n\n  var shape = new PolygonShape(vertices);\n  return shape;\n};\n\nPolygonShape.prototype.getVertex = function(index) {\n  _ASSERT && common.assert(0 <= index && index < this.m_count);\n  return this.m_vertices[index];\n}\n\n/**\n * @deprecated\n */\nPolygonShape.prototype._clone = function() {\n  var clone = new PolygonShape();\n  clone.m_type = this.m_type;\n  clone.m_radius = this.m_radius;\n  clone.m_count = this.m_count;\n  clone.m_centroid.set(this.m_centroid);\n  for (var i = 0; i < this.m_count; i++) {\n    clone.m_vertices.push(this.m_vertices[i].clone());\n  }\n  for (var i = 0; i < this.m_normals.length; i++) {\n    clone.m_normals.push(this.m_normals[i].clone());\n  }\n  return clone;\n}\n\nPolygonShape.prototype.getChildCount = function() {\n  return 1;\n}\n\nfunction ComputeCentroid(vs, count) {\n  _ASSERT && common.assert(count >= 3);\n\n  var c = Vec2.zero();\n  var area = 0.0;\n\n  // pRef is the reference point for forming triangles.\n  // It's location doesn't change the result (except for rounding error).\n  var pRef = Vec2.zero();\n  if (false) {\n    // This code would put the reference point inside the polygon.\n    for (var i = 0; i < count; ++i) {\n      pRef.add(vs[i]);\n    }\n    pRef.mul(1.0 / count);\n  }\n\n  var inv3 = 1.0 / 3.0;\n\n  for (var i = 0; i < count; ++i) {\n    // Triangle vertices.\n    var p1 = pRef;\n    var p2 = vs[i];\n    var p3 = i + 1 < count ? vs[i + 1] : vs[0];\n\n    var e1 = Vec2.sub(p2, p1);\n    var e2 = Vec2.sub(p3, p1);\n\n    var D = Vec2.cross(e1, e2);\n\n    var triangleArea = 0.5 * D;\n    area += triangleArea;\n\n    // Area weighted centroid\n    c.addMul(triangleArea * inv3, p1);\n    c.addMul(triangleArea * inv3, p2);\n    c.addMul(triangleArea * inv3, p3);\n  }\n\n  // Centroid\n  _ASSERT && common.assert(area > Math.EPSILON);\n  c.mul(1.0 / area);\n  return c;\n}\n\nPolygonShape.prototype._reset = function() {\n  this._set(this.m_vertices)\n}\n\n/**\n * @private\n *\n * Create a convex hull from the given array of local points. The count must be\n * in the range [3, Settings.maxPolygonVertices].\n *\n * Warning: the points may be re-ordered, even if they form a convex polygon\n * Warning: collinear points are handled but not removed. Collinear points may\n * lead to poor stacking behavior.\n */\nPolygonShape.prototype._set = function(vertices) {\n  _ASSERT && common.assert(3 <= vertices.length && vertices.length <= Settings.maxPolygonVertices);\n  if (vertices.length < 3) {\n    this._setAsBox(1.0, 1.0);\n    return;\n  }\n\n  var n = Math.min(vertices.length, Settings.maxPolygonVertices);\n\n  // Perform welding and copy vertices into local buffer.\n  var ps = []; // [Settings.maxPolygonVertices];\n  for (var i = 0; i < n; ++i) {\n    var v = vertices[i];\n\n    var unique = true;\n    for (var j = 0; j < ps.length; ++j) {\n      if (Vec2.distanceSquared(v, ps[j]) < 0.25 * Settings.linearSlopSquared) {\n        unique = false;\n        break;\n      }\n    }\n\n    if (unique) {\n      ps.push(v);\n    }\n  }\n\n  n = ps.length;\n  if (n < 3) {\n    // Polygon is degenerate.\n    _ASSERT && common.assert(false);\n    this._setAsBox(1.0, 1.0);\n    return;\n  }\n\n  // Create the convex hull using the Gift wrapping algorithm\n  // http://en.wikipedia.org/wiki/Gift_wrapping_algorithm\n\n  // Find the right most point on the hull (in case of multiple points bottom most is used)\n  var i0 = 0;\n  var x0 = ps[0].x;\n  for (var i = 1; i < n; ++i) {\n    var x = ps[i].x;\n    if (x > x0 || (x === x0 && ps[i].y < ps[i0].y)) {\n      i0 = i;\n      x0 = x;\n    }\n  }\n\n  var hull = []; // [Settings.maxPolygonVertices];\n  var m = 0;\n  var ih = i0;\n\n  for (;;) {\n    hull[m] = ih;\n\n    var ie = 0;\n    for (var j = 1; j < n; ++j) {\n      if (ie === ih) {\n        ie = j;\n        continue;\n      }\n\n      var r = Vec2.sub(ps[ie], ps[hull[m]]);\n      var v = Vec2.sub(ps[j], ps[hull[m]]);\n      var c = Vec2.cross(r, v);\n      // c < 0 means counter-clockwise wrapping, c > 0 means clockwise wrapping\n      if (c < 0.0) {\n        ie = j;\n      }\n\n      // Collinearity check\n      if (c === 0.0 && v.lengthSquared() > r.lengthSquared()) {\n        ie = j;\n      }\n    }\n\n    ++m;\n    ih = ie;\n\n    if (ie === i0) {\n      break;\n    }\n  }\n\n  if (m < 3) {\n    // Polygon is degenerate.\n    _ASSERT && common.assert(false);\n    this._setAsBox(1.0, 1.0);\n    return;\n  }\n\n  this.m_count = m;\n\n  // Copy vertices.\n  this.m_vertices = [];\n  for (var i = 0; i < m; ++i) {\n    this.m_vertices[i] = ps[hull[i]];\n  }\n\n  // Compute normals. Ensure the edges have non-zero length.\n  for (var i = 0; i < m; ++i) {\n    var i1 = i;\n    var i2 = i + 1 < m ? i + 1 : 0;\n    var edge = Vec2.sub(this.m_vertices[i2], this.m_vertices[i1]);\n    _ASSERT && common.assert(edge.lengthSquared() > Math.EPSILON * Math.EPSILON);\n    this.m_normals[i] = Vec2.cross(edge, 1.0);\n    this.m_normals[i].normalize();\n  }\n\n  // Compute the polygon centroid.\n  this.m_centroid = ComputeCentroid(this.m_vertices, m);\n}\n\n/**\n * @private\n */\nPolygonShape.prototype._setAsBox = function(hx, hy, center, angle) {\n  // start with right-bottom, counter-clockwise, as in Gift wrapping algorithm in PolygonShape._set()\n  this.m_vertices[0] = Vec2.neo(hx, -hy);\n  this.m_vertices[1] = Vec2.neo(hx, hy);\n  this.m_vertices[2] = Vec2.neo(-hx, hy);\n  this.m_vertices[3] = Vec2.neo(-hx, -hy);\n\n  this.m_normals[0] = Vec2.neo(1.0, 0.0);\n  this.m_normals[1] = Vec2.neo(0.0, 1.0);\n  this.m_normals[2] = Vec2.neo(-1.0, 0.0);\n  this.m_normals[3] = Vec2.neo(0.0, -1.0);\n\n  this.m_count = 4;\n\n  if (Vec2.isValid(center)) {\n    angle = angle || 0;\n\n    this.m_centroid.set(center);\n\n    var xf = Transform.identity();\n    xf.p.set(center);\n    xf.q.set(angle);\n\n    // Transform vertices and normals.\n    for (var i = 0; i < this.m_count; ++i) {\n      this.m_vertices[i] = Transform.mulVec2(xf, this.m_vertices[i]);\n      this.m_normals[i] = Rot.mulVec2(xf.q, this.m_normals[i]);\n    }\n  }\n}\n\nPolygonShape.prototype.testPoint = function(xf, p) {\n  var pLocal = Rot.mulTVec2(xf.q, Vec2.sub(p, xf.p));\n\n  for (var i = 0; i < this.m_count; ++i) {\n    var dot = Vec2.dot(this.m_normals[i], Vec2.sub(pLocal, this.m_vertices[i]));\n    if (dot > 0.0) {\n      return false;\n    }\n  }\n\n  return true;\n}\n\nPolygonShape.prototype.rayCast = function(output, input, xf, childIndex) {\n\n  // Put the ray into the polygon's frame of reference.\n  var p1 = Rot.mulTVec2(xf.q, Vec2.sub(input.p1, xf.p));\n  var p2 = Rot.mulTVec2(xf.q, Vec2.sub(input.p2, xf.p));\n  var d = Vec2.sub(p2, p1);\n\n  var lower = 0.0;\n  var upper = input.maxFraction;\n\n  var index = -1;\n\n  for (var i = 0; i < this.m_count; ++i) {\n    // p = p1 + a * d\n    // dot(normal, p - v) = 0\n    // dot(normal, p1 - v) + a * dot(normal, d) = 0\n    var numerator = Vec2.dot(this.m_normals[i], Vec2.sub(this.m_vertices[i], p1));\n    var denominator = Vec2.dot(this.m_normals[i], d);\n\n    if (denominator == 0.0) {\n      if (numerator < 0.0) {\n        return false;\n      }\n    } else {\n      // Note: we want this predicate without division:\n      // lower < numerator / denominator, where denominator < 0\n      // Since denominator < 0, we have to flip the inequality:\n      // lower < numerator / denominator <==> denominator * lower > numerator.\n      if (denominator < 0.0 && numerator < lower * denominator) {\n        // Increase lower.\n        // The segment enters this half-space.\n        lower = numerator / denominator;\n        index = i;\n      } else if (denominator > 0.0 && numerator < upper * denominator) {\n        // Decrease upper.\n        // The segment exits this half-space.\n        upper = numerator / denominator;\n      }\n    }\n\n    // The use of epsilon here causes the assert on lower to trip\n    // in some cases. Apparently the use of epsilon was to make edge\n    // shapes work, but now those are handled separately.\n    // if (upper < lower - Math.EPSILON)\n    if (upper < lower) {\n      return false;\n    }\n  }\n\n  _ASSERT && common.assert(0.0 <= lower && lower <= input.maxFraction);\n\n  if (index >= 0) {\n    output.fraction = lower;\n    output.normal = Rot.mulVec2(xf.q, this.m_normals[index]);\n    return true;\n  }\n\n  return false;\n};\n\nPolygonShape.prototype.computeAABB = function(aabb, xf, childIndex) {\n  var minX = Infinity, minY = Infinity;\n  var maxX = -Infinity, maxY = -Infinity;\n  for (var i = 0; i < this.m_count; ++i) {\n    var v = Transform.mulVec2(xf, this.m_vertices[i]);\n    minX = Math.min(minX, v.x);\n    maxX = Math.max(maxX, v.x);\n    minY = Math.min(minY, v.y);\n    maxY = Math.max(maxY, v.y);\n  }\n\n  aabb.lowerBound.set(minX, minY);\n  aabb.upperBound.set(maxX, maxY);\n  aabb.extend(this.m_radius);\n}\n\nPolygonShape.prototype.computeMass = function(massData, density) {\n  // Polygon mass, centroid, and inertia.\n  // Let rho be the polygon density in mass per unit area.\n  // Then:\n  // mass = rho * int(dA)\n  // centroid.x = (1/mass) * rho * int(x * dA)\n  // centroid.y = (1/mass) * rho * int(y * dA)\n  // I = rho * int((x*x + y*y) * dA)\n  //\n  // We can compute these integrals by summing all the integrals\n  // for each triangle of the polygon. To evaluate the integral\n  // for a single triangle, we make a change of variables to\n  // the (u,v) coordinates of the triangle:\n  // x = x0 + e1x * u + e2x * v\n  // y = y0 + e1y * u + e2y * v\n  // where 0 <= u && 0 <= v && u + v <= 1.\n  //\n  // We integrate u from [0,1-v] and then v from [0,1].\n  // We also need to use the Jacobian of the transformation:\n  // D = cross(e1, e2)\n  //\n  // Simplification: triangle centroid = (1/3) * (p1 + p2 + p3)\n  //\n  // The rest of the derivation is handled by computer algebra.\n\n  _ASSERT && common.assert(this.m_count >= 3);\n\n  var center = Vec2.zero();\n  var area = 0.0;\n  var I = 0.0;\n\n  // s is the reference point for forming triangles.\n  // It's location doesn't change the result (except for rounding error).\n  var s = Vec2.zero();\n\n  // This code would put the reference point inside the polygon.\n  for (var i = 0; i < this.m_count; ++i) {\n    s.add(this.m_vertices[i]);\n  }\n  s.mul(1.0 / this.m_count);\n\n  var k_inv3 = 1.0 / 3.0;\n\n  for (var i = 0; i < this.m_count; ++i) {\n    // Triangle vertices.\n    var e1 = Vec2.sub(this.m_vertices[i], s);\n    var e2 = i + 1 < this.m_count ? Vec2.sub(this.m_vertices[i + 1], s) : Vec2\n        .sub(this.m_vertices[0], s);\n\n    var D = Vec2.cross(e1, e2);\n\n    var triangleArea = 0.5 * D;\n    area += triangleArea;\n\n    // Area weighted centroid\n    center.addCombine(triangleArea * k_inv3, e1, triangleArea * k_inv3, e2);\n\n    var ex1 = e1.x;\n    var ey1 = e1.y;\n    var ex2 = e2.x;\n    var ey2 = e2.y;\n\n    var intx2 = ex1 * ex1 + ex2 * ex1 + ex2 * ex2;\n    var inty2 = ey1 * ey1 + ey2 * ey1 + ey2 * ey2;\n\n    I += (0.25 * k_inv3 * D) * (intx2 + inty2);\n  }\n\n  // Total mass\n  massData.mass = density * area;\n\n  // Center of mass\n  _ASSERT && common.assert(area > Math.EPSILON);\n  center.mul(1.0 / area);\n  massData.center.setCombine(1, center, 1, s);\n\n  // Inertia tensor relative to the local origin (point s).\n  massData.I = density * I;\n\n  // Shift to center of mass then to original body origin.\n  massData.I += massData.mass\n      * (Vec2.dot(massData.center, massData.center) - Vec2.dot(center, center));\n}\n\n// Validate convexity. This is a very time consuming operation.\n// @returns true if valid\nPolygonShape.prototype.validate = function() {\n  for (var i = 0; i < this.m_count; ++i) {\n    var i1 = i;\n    var i2 = i < this.m_count - 1 ? i1 + 1 : 0;\n    var p = this.m_vertices[i1];\n    var e = Vec2.sub(this.m_vertices[i2], p);\n\n    for (var j = 0; j < this.m_count; ++j) {\n      if (j == i1 || j == i2) {\n        continue;\n      }\n\n      var v = Vec2.sub(this.m_vertices[j], p);\n      var c = Vec2.cross(e, v);\n      if (c < 0.0) {\n        return false;\n      }\n    }\n  }\n\n  return true;\n}\n\nPolygonShape.prototype.computeDistanceProxy = function(proxy) {\n  proxy.m_vertices = this.m_vertices;\n  proxy.m_count = this.m_count;\n  proxy.m_radius = this.m_radius;\n};\n","/*\n * Copyright (c) 2016-2018 Ali Shakiba http://shakiba.me/planck.js\n *\n * This software is provided 'as-is', without any express or implied\n * warranty.  In no event will the authors be held liable for any damages\n * arising from the use of this software.\n * Permission is granted to anyone to use this software for any purpose,\n * including commercial applications, and to alter it and redistribute it\n * freely, subject to the following restrictions:\n * 1. The origin of this software must not be misrepresented; you must not\n * claim that you wrote the original software. If you use this software\n * in a product, an acknowledgment in the product documentation would be\n * appreciated but is not required.\n * 2. Altered source versions must be plainly marked as such, and must not be\n * misrepresented as being the original software.\n * 3. This notice may not be removed or altered from any source distribution.\n */\n\nvar _DEBUG = typeof DEBUG === 'undefined' ? false : DEBUG;\nvar _ASSERT = typeof ASSERT === 'undefined' ? false : ASSERT;\n\nmodule.exports = Pool;\n\nfunction Pool(opts) {\n  var _list = [];\n  var _max = opts.max || Infinity;\n\n  var _createFn = opts.create;\n  var _outFn = opts.allocate;\n  var _inFn = opts.release;\n  var _discardFn = opts.discard;\n\n  var _createCount = 0;\n  var _outCount = 0;\n  var _inCount = 0;\n  var _discardCount = 0;\n\n  this.max = function(n) {\n    if (typeof n === 'number') {\n      _max = n;\n      return this;\n    }\n    return _max;\n  };\n\n  this.size = function() {\n    return _list.length;\n  };\n\n  this.allocate = function() {\n    var item;\n    if (_list.length > 0) {\n      item = _list.shift();\n    } else {\n      _createCount++;\n      if (typeof _createFn === 'function') {\n        item = _createFn();\n      } else {\n        item = {};\n      }\n    }\n    _outCount++;\n    if (typeof _outFn === 'function') {\n      _outFn(item);\n    }\n    return item;\n  };\n\n  this.release = function(item) {\n    if (_list.length < _max) {\n      _inCount++;\n      if (typeof _inFn === 'function') {\n        _inFn(item);\n      }\n      _list.push(item);\n    } else {\n      _discardCount++;\n      if (typeof _discardFn === 'function') {\n        item = _discardFn(item);\n      }\n    }\n  };\n\n  this.toString = function() {\n    return \" +\" + _createCount + \" >\" + _outCount + \" <\" + _inCount + \" -\"\n        + _discardCount + \" =\" + _list.length + \"/\" + _max;\n  };\n}","var _DEBUG = typeof DEBUG === 'undefined' ? false : DEBUG;\nvar _ASSERT = typeof ASSERT === 'undefined' ? false : ASSERT;\n\nmodule.exports.now = function() {\n  return Date.now();\n}\n\nmodule.exports.diff = function(time) {\n  return Date.now() - time;\n}\n","var _DEBUG = typeof DEBUG === 'undefined' ? false : DEBUG;\nvar _ASSERT = typeof ASSERT === 'undefined' ? false : ASSERT;\n\nexports.debug = function() {\n  if (!_DEBUG) return;\n  console.log.apply(console, arguments);\n};\n\nexports.assert = function(statement, err, log) {\n  if (!_ASSERT) return;\n  if (statement) return;\n  log && console.log(log);\n  throw new Error(err);\n};","var _DEBUG = typeof DEBUG === 'undefined' ? false : DEBUG;\nvar _ASSERT = typeof ASSERT === 'undefined' ? false : ASSERT;\n\nvar propIsEnumerable = Object.prototype.propertyIsEnumerable;\n\nmodule.exports = function(input, defaults) {\n  if (input === null || typeof input === 'undefined') {\n    input = {};\n  }\n\n  var output = Object.assign({}, input);\n\n  for ( var key in defaults) {\n    if (defaults.hasOwnProperty(key) && typeof input[key] === 'undefined') {\n      output[key] = defaults[key];\n    }\n  }\n\n  if (typeof Object.getOwnPropertySymbols === 'function') {\n    var symbols = Object.getOwnPropertySymbols(defaults);\n    for (var i = 0; i < symbols.length; i++) {\n      var symbol = symbols[i];\n      if (defaults.propertyIsEnumerable(symbol) && typeof input[key] === 'undefined') {\n        output[symbol] = defaults[symbol];\n      }\n    }\n  }\n\n  return output;\n};\n"],"names":["openDB","name","version","blocked","upgrade","blocking","terminated","request","indexedDB","open","openPromise","w","addEventListener","event","result","oldVersion","newVersion","transaction","then","db","catch","readMethods","writeMethods","cachedMethods","Map","getMethod","target","prop","IDBDatabase","get","targetFuncName","replace","useIndex","isWrite","includes","IDBIndex","IDBObjectStore","prototype","method","async","storeName","args","tx","this","store","index","shift","Promise","all","done","set","r","oldTraps","receiver","has","instanceOfAny","object","constructors","some","c","idbProxyableTypes","cursorAdvanceMethods","cursorRequestMap","WeakMap","transactionDoneMap","transactionStoreNamesMap","transformCache","reverseTransformCache","idbProxyTraps","IDBTransaction","objectStoreNames","undefined","objectStore","wrap","value","replaceTraps","callback","wrapFunction","func","IDBCursor","advance","continue","continuePrimaryKey","apply","unwrap","storeNames","call","sort","transformCachableValue","resolve","reject","unlisten","removeEventListener","complete","error","DOMException","cacheDonePromiseForTransaction","Proxy","IDBRequest","promise","success","promisifyRequest","newValue","advanceMethodProps","methodMap","advanceResults","ittrProxiedCursorToOriginalProxy","cursorIteratorTraps","cachedFunc","iterate","cursor","openCursor","proxiedCursor","u","delete","isIteratorProp","Symbol","asyncIterator","i","DEBUG","_ASSERT","ASSERT","module","exports","Body","common","options","Vec2","Rot","Math","Sweep","Transform","Velocity","Position","Fixture","staticBody","STATIC","kinematicBody","KINEMATIC","dynamicBody","DYNAMIC","BodyDef","type","position","zero","angle","linearVelocity","angularVelocity","linearDamping","angularDamping","fixedRotation","bullet","gravityScale","allowSleep","awake","active","userData","world","def","assert","isValid","isFinite","m_world","m_awakeFlag","m_autoSleepFlag","m_bulletFlag","m_fixedRotationFlag","m_activeFlag","m_islandFlag","m_toiFlag","m_userData","m_type","m_mass","m_invMass","m_I","m_invI","m_xf","identity","p","clone","q","setAngle","m_sweep","setTransform","c_velocity","c_position","m_force","m_torque","m_linearVelocity","m_angularVelocity","m_linearDamping","m_angularDamping","m_gravityScale","m_sleepTime","m_jointList","m_contactList","m_fixtureList","m_prev","m_next","m_destroyed","MassData","mass","center","I","_serialize","fixtures","f","push","getAngle","_deserialize","data","restore","body","length","fixture","_addFixture","isWorldLocked","isLocked","getWorld","getNext","setUserData","getUserData","getFixtureList","getJointList","getContactList","isStatic","isDynamic","isKinematic","setStatic","setType","setDynamic","setKinematic","getType","resetMassData","setZero","forward","synchronizeFixtures","setAwake","ce","ce0","next","destroyContact","contact","broadPhase","m_broadPhase","proxyCount","m_proxyCount","touchProxy","m_proxies","proxyId","isBullet","setBullet","flag","isSleepingAllowed","setSleepingAllowed","isAwake","isActive","setActive","createProxies","destroyProxies","isFixedRotation","setFixedRotation","getTransform","synchronize","synchronizeTransform","xf","alpha","c0","a","a0","getPosition","setPosition","getWorldCenter","getLocalCenter","localCenter","getLinearVelocity","getLinearVelocityFromWorldPoint","worldPoint","sub","add","cross","getLinearVelocityFromLocalPoint","localPoint","getWorldPoint","setLinearVelocity","v","dot","getAngularVelocity","setAngularVelocity","getLinearDamping","setLinearDamping","getAngularDamping","setAngularDamping","getGravityScale","setGravityScale","scale","getMass","getInertia","getMassData","m_density","massData","addMul","mul","oldCenter","setLocalCenter","setMassData","applyForce","force","point","wake","applyForceToCenter","applyTorque","torque","applyLinearImpulse","impulse","applyAngularImpulse","shouldCollide","that","jn","other","joint","m_collideConnected","m_newFixture","createFixture","shape","fixdef","destroyFixture","m_body","found","node","edge","fixtureA","getFixtureA","fixtureB","getFixtureB","publish","mulVec2","getWorldVector","localVector","getLocalPoint","mulTVec2","getLocalVector","worldVector","Mat22","Settings","Manifold","Distance","ContactEdge","prev","Contact","fA","indexA","fB","indexB","evaluateFcn","m_nodeA","m_nodeB","m_fixtureA","m_fixtureB","m_indexA","m_indexB","m_evaluateFcn","m_manifold","m_toi","m_toiCount","m_friction","mixFriction","m_restitution","mixRestitution","m_tangentSpeed","m_enabledFlag","m_touchingFlag","m_filterFlag","m_bulletHitFlag","v_points","v_normal","v_normalMass","v_K","v_pointCount","v_tangentSpeed","v_friction","v_restitution","v_invMassA","v_invMassB","v_invIA","v_invIB","p_localPoints","p_localNormal","p_localPoint","p_localCenterA","p_localCenterB","p_type","p_radiusA","p_radiusB","p_pointCount","p_invMassA","p_invMassB","p_invIA","p_invIB","VelocityConstraintPoint","rA","rB","normalImpulse","tangentImpulse","normalMass","tangentMass","velocityBias","friction1","friction2","sqrt","restitution1","restitution2","initConstraint","step","shapeA","getShape","shapeB","bodyA","getBody","bodyB","manifold","getManifold","pointCount","m_radius","localNormal","j","cp","points","vcp","warmStarting","dtRatio","getWorldManifold","worldManifold","setEnabled","isEnabled","isTouching","getChildIndexA","getChildIndexB","flagForFiltering","setFriction","friction","getFriction","resetFriction","setRestitution","restitution","getRestitution","resetRestitution","setTangentSpeed","speed","getTangentSpeed","evaluate","xfA","xfB","update","listener","touching","wasTouching","sensorA","isSensor","sensorB","sensor","testOverlap","oldManifold","nmp","omp","id","key","beginContact","endContact","preSolve","solvePositionConstraint","_solvePositionConstraint","solvePositionConstraintTOI","toiA","toiB","toi","positionA","positionB","localCenterA","localCenterB","mA","iA","mB","iB","cA","aA","cB","aB","minSeparation","normal","separation","e_circles","pointA","pointB","normalize","combine","e_faceA","planePoint","clipPoint","e_faceB","min","baumgarte","toiBaugarte","linearSlop","maxLinearCorrection","C","clamp","rnA","rnB","K","P","subMul","initVelocityConstraint","velocityA","velocityB","radiusA","radiusB","vA","wA","vB","wB","setCombine","kNormal","tangent","rtA","rtB","kTangent","vRel","velocityThreshold","blockSolve","vcp1","vcp2","rn1A","rn1B","rn2A","rn2B","k11","k22","k12","ex","ey","getInverse","warmStartConstraint","storeConstraintImpulses","solveVelocityConstraint","dv","addCombine","subCombine","vt","lambda","maxFriction","newImpulse","vn","max","neo","x","y","dv1","dv2","vn1","vn2","b","neg","d","P1","P2","s_registers","addType","type1","type2","create","typeA","typeB","destroy","destroyFcn","AABB","Shape","FixtureDef","density","filterGroupIndex","filterCategoryBits","filterMaskBits","FixtureProxy","childIndex","aabb","m_isSensor","m_filterGroupIndex","m_filterCategoryBits","m_filterMaskBits","m_shape","childCount","getChildCount","_reset","setSensor","getDensity","setDensity","testPoint","rayCast","output","input","computeMass","getAABB","proxy","computeAABB","createProxy","destroyProxy","xf1","xf2","aabb1","aabb2","displacement","moveProxy","setFilterData","filter","groupIndex","categoryBits","maskBits","refilter","getFilterGroupIndex","setFilterGroupIndex","getFilterCategoryBits","setFilterCategoryBits","getFilterMaskBits","setFilterMaskBits","collideA","collideB","Joint","JointEdge","m_bodyA","m_bodyB","m_index","collideConnected","m_edgeA","m_edgeB","TYPES","context","clazz","getBodyA","getBodyB","getCollideConnected","getAnchorA","getAnchorB","getReactionForce","inv_dt","getReactionTorque","shiftOrigin","newOrigin","initVelocityConstraints","solveVelocityConstraints","solvePositionConstraints","ManifoldPoint","ContactID","cf","ContactFeature","WorldManifold","separations","clipSegmentToLine","vOut","vIn","offset","vertexIndexA","numOut","distance0","distance1","interp","e_vertex","e_face","clipVertex","ClipVertex","getPointStates","state1","state2","manifold1","manifold2","PointState","removeState","persistState","addState","Object","defineProperty","enumerable","configurable","o","wm","dist","lengthSquared","EPSILON","mid","nullState","maxManifoldPoints","maxPolygonVertices","aabbExtension","aabbMultiplier","linearSlopSquared","angularSlop","PI","polygonRadius","maxSubSteps","maxTOIContacts","maxTOIIterations","maxDistnceIterations","maxAngularCorrection","maxTranslation","maxTranslationSquared","maxRotation","maxRotationSquared","timeToSleep","linearSleepTolerance","linearSleepToleranceSqr","pow","angularSleepTolerance","angularSleepToleranceSqr","getRadius","_clone","transform","computeDistanceProxy","_DEBUG","Solver","TimeStep","TimeOfImpact","TOIInput","Input","TOIOutput","Output","Cache","dt","velocityIterations","positionIterations","inv_dt0","m_stack","m_bodies","m_contacts","m_joints","reset","clear","addBody","addContact","addJoint","solveWorld","m_bodyList","stack","seed","pop","je","solveIsland","gravity","m_gravity","m_allowSleep","h","printBodies","translation","ratio","rotation","abs","positionSolved","contactsOkay","jointsOkay","jointOkay","postSolveIsland","minSleepTime","Infinity","linTolSqr","angTolSqr","tag","debug","s_subStep","ContactImpulse","normalImpulses","tangentImpulses","solveWorldTOI","m_stepComplete","alpha0","minContact","minAlpha","bA","bB","activeA","activeB","proxyA","proxyB","sweepA","sweepB","tMax","beta","t","state","e_touching","backup1","backup2","bodies","backup","solveIslandTOI","findNewContacts","m_subStepping","subStep","postSolve","World","BroadPhase","WorldDef","continuousPhysics","subStepping","m_solver","m_contactCount","m_bodyCount","m_jointCount","m_clearForces","m_locked","m_warmStarting","m_continuousPhysics","m_blockSolve","m_velocityIterations","m_positionIterations","m_t","addPair","createContact","bind","joints","getBodyList","_addBody","createJoint","getBodyCount","getJointCount","getContactCount","setGravity","getGravity","setAllowSleeping","getAllowSleeping","setWarmStarting","getWarmStarting","setContinuousPhysics","getContinuousPhysics","setSubStepping","getSubStepping","setAutoClearForces","getAutoClearForces","clearForces","queryAABB","queryCallback","query","point1","point2","reportFixtureCallback","maxFraction","p1","p2","fraction","getProxyCount","getTreeHeight","getTreeBalance","getTreeQuality","createBody","createDynamicBody","createKinematicBody","destroyBody","je0","destroyJoint","f0","s_step","timeStep","updateContacts","updatePairs","next_c","proxyIdA","proxyIdB","_listeners","on","off","listeners","indexOf","splice","arg1","arg2","arg3","l","lower","upper","lowerBound","upperBound","Error","getCenter","getExtents","getPerimeter","lowerA","upperA","lowerB","upperB","lowerX","lowerY","upperX","upperY","combinePoints","contains","extend","d1x","d2x","d1y","d2y","areEqual","diff","wD","hD","tmin","tmax","absD","inv_d","t1","t2","s","temp","toString","JSON","stringify","DynamicTree","m_tree","m_moveBuffer","aabbA","getFatAABB","aabbB","getHeight","getMaxBalance","getAreaRatio","rayCastCallback","bufferMove","unbufferMove","addPairCallback","m_callback","m_queryProxyId","fatAABB","userDataA","userDataB","DistanceInput","DistanceOutput","DistanceProxy","SimplexCache","stats","transformA","transformB","useRadii","distance","iterations","metric","count","cache","gjkCalls","simplex","Simplex","readCache","vertices","m_v","k_maxIters","saveA","saveB","saveCount","iter","m_count","solve","getClosestPoint","getSearchDirection","vertex","getSupport","getVertex","gjkIters","duplicate","gjkMaxIters","getWitnessPoints","writeCache","m_buffer","m_vertices","SimplexVertex","m_v1","m_v2","m_v3","getVertexCount","bestIndex","bestValue","getSupportVertex","print","wALocal","wBLocal","metric1","metric2","getMetric","e12","pA","pB","solve2","solve3","w1","w2","d12_2","d12_1","inv_d12","w3","w1e12","e13","w1e13","d13_1","d13_2","e23","w2e23","d23_1","d23_2","n123","d123_1","d123_2","d123_3","inv_d13","inv_d23","inv_d123","Pool","TreeNode","parent","child1","child2","height","m_root","m_nodes","m_lastProxyId","m_pool","isLeaf","allocateNode","allocate","freeNode","release","insertLeaf","removeLeaf","leaf","leafAABB","area","combinedAABB","cost1","cost2","combinedArea","cost","inheritanceCost","oldArea","sibling","oldParent","newParent","balance","grandParent","A","B","F","G","D","E","rootArea","totalArea","it","iteratorPool","preorder","computeHeight","height1","height2","validateStructure","validateMetrics","validate","maxBalance","rebuildBottomUp","nodes","minCost","iMin","jMin","aabbi","aabbj","stackPool","abs_v","segmentAABB","subInput","inputPool","Iterator","iterator","close","parents","states","root","timer","Timer","now","toiCalls","e_unknown","totalRadius","tolerance","k_maxIterations","distanceInput","distanceOutput","e_overlapped","fcn","SeparationFunction","initialize","pushBackIter","s2","findMinSeparation","e_separated","s1","e_failed","rootIterCount","a1","a2","toiRootIters","toiMaxRootIters","toiIters","toiMaxIters","time","toiMaxTime","toiTime","m_proxyA","m_proxyB","m_sweepA","m_sweepB","m_localPoint","m_axis","localPointA","localPointB","localPointB1","localPointB2","localPointA1","localPointA2","compute","find","axisA","axisB","setIdentity","det","imx","mx","mulMat22","mulT","mulTMat22","mx1","mx2","Mat33","Vec3","ez","solve33","z","solve22","a11","a12","a21","a22","getInverse22","M","getSymInverse33","a13","a23","a33","mulVec3","native","math","isNaN","invSqrt","nextPowerOfTwo","isPowerOfTwo","mod","num","random","obj","rot","sin","cos","atan2","getXAxis","getYAxis","m","qr","mulRot","mulSub","mulTRot","Array","isArray","arr","mulAll","mulFn","mulXf","px","py","mulTXf","wSet","setMul","wAdd","wSub","lengthOf","invLength","dx","dy","distanceSquared","skew","addCross","lengthSqr","scaleFn","translateFn","newline","string","internal","Circle","Polygon","Box","CollidePolygons","DistanceJoint","TYPE","_super","DEFAULTS","frequencyHz","dampingRatio","anchorA","anchorB","m_localAnchorA","localAnchorA","m_localAnchorB","localAnchorB","m_length","m_frequencyHz","m_dampingRatio","m_impulse","m_gamma","m_bias","m_u","m_rA","m_rB","m_localCenterA","m_localCenterB","m_invMassA","m_invMassB","m_invIA","m_invIB","gamma","bias","assign","_setAnchors","getLocalAnchorA","getLocalAnchorB","setLength","getLength","setFrequency","hz","getFrequency","setDampingRatio","getDampingRatio","qA","qB","crAu","crBu","invMass","omega","k","vpA","vpB","Cdot","FrictionJoint","maxForce","maxTorque","anchor","m_linearImpulse","m_angularImpulse","m_maxForce","m_maxTorque","m_linearMass","m_angularMass","setMaxForce","getMaxForce","setMaxTorque","getMaxTorque","oldImpulse","maxImpulse","GearJoint","RevoluteJoint","PrismaticJoint","joint1","joint2","coordinateA","coordinateB","m_joint1","m_joint2","m_ratio","m_type1","m_type2","m_bodyC","xfC","aC","revolute","m_localAnchorC","m_referenceAngleA","m_referenceAngle","m_localAxisC","prismatic","m_localXAxisA","pC","m_bodyD","xfD","aD","m_localAnchorD","m_referenceAngleB","m_localAxisD","pD","m_constant","m_lcA","m_lcB","m_lcC","m_lcD","m_mA","m_mB","m_mC","m_mD","m_iA","m_iB","m_iC","m_iD","m_JvAC","m_JvBD","m_JwA","m_JwB","m_JwC","m_JwD","getJoint1","getJoint2","setRatio","getRatio","vC","wC","vD","qC","qD","rC","rD","JvAC","JvBD","JwA","JwB","JwC","JwD","cC","cD","MotorJoint","correctionFactor","m_linearOffset","linearOffset","m_angularOffset","angularOffset","m_correctionFactor","m_linearError","m_angularError","setCorrectionFactor","factor","getCorrectionFactor","setLinearOffset","getLinearOffset","setAngularOffset","getAngularOffset","inv_h","MouseJoint","m_targetA","m_beta","m_C","_localAnchorB","setTarget","getTarget","velocity","inactiveLimit","enableLimit","lowerTranslation","upperTranslation","enableMotor","maxMotorForce","motorSpeed","axis","localAxisA","m_localYAxisA","referenceAngle","m_motorMass","m_motorImpulse","m_lowerTranslation","m_upperTranslation","m_maxMotorForce","m_motorSpeed","m_enableLimit","m_enableMotor","m_limitState","m_perp","m_s1","m_s2","m_a1","m_a2","m_K","getLocalAxisA","getReferenceAngle","getJointTranslation","getJointSpeed","isLimitEnabled","getLowerLimit","getUpperLimit","setLimits","isMotorEnabled","setMotorSpeed","setMaxMotorForce","getMaxMotorForce","getMotorSpeed","getMotorForce","k13","k23","k33","jointTranslation","LA","LB","Cdot1","Cdot2","f1","df","f2r","perp","C1","linearError","angularError","C2","impulse1","PulleyJoint","MIN_PULLEY_LENGTH","PulleyJointDef","groundA","groundB","m_groundAnchorA","groundAnchorA","m_groundAnchorB","groundAnchorB","m_lengthA","lengthA","m_lengthB","lengthB","m_uA","m_uB","getGroundAnchorA","getGroundAnchorB","getLengthA","getLengthB","getCurrentLengthA","getCurrentLengthB","ruA","ruB","PA","PB","uA","uB","lowerAngle","upperAngle","maxMotorTorque","m_lowerAngle","m_upperAngle","m_maxMotorTorque","getJointAngle","getMotorTorque","setMaxMotorTorque","getMaxMotorTorque","jointAngle","rhs","reduced","positionError","limitImpulse","RopeJoint","maxLength","m_maxLength","m_state","setMaxLength","getMaxLength","getLimitState","crA","crB","WeldJoint","invM","impulse2","WheelJoint","localAxis","m_springMass","m_springImpulse","m_ax","m_ay","m_sAx","m_sBx","m_sAy","m_sBy","setSpringFrequencyHz","getSpringFrequencyHz","setSpringDampingRatio","getSpringDampingRatio","ay","sAy","sBy","SID","Serializer","opts","rootClass","preSerialize","postSerialize","preDeserialize","postDeserialize","refTypes","restoreTypes","toJson","json","queue","refMap","storeRef","typeName","__sid","ref","refIndex","refType","top","serialize","hasOwnProperty","str","fromJson","deserialize","cls","ctx","restoreRef","serializer","BoxShape","PolygonShape","hx","hy","_setAsBox","ChainShape","EdgeShape","loop","m_prevVertex","m_nextVertex","m_hasPrevVertex","m_hasNextVertex","m_isLoop","_createLoop","_createChain","isLoop","hasPrevVertex","hasNextVertex","prevVertex","nextVertex","setPrevVertex","setNextVertex","v1","v2","createChain","getChildEdge","m_vertex1","m_vertex2","m_vertex0","m_hasVertex0","m_vertex3","m_hasVertex3","CircleShape","m_p","radius","rr","sigma","CollideCircles","circleA","circleB","distSqr","polygonA","cLocal","normalIndex","vertexCount","normals","m_normals","vertIndex1","vertIndex2","u1","u2","faceCenter","CollidePolygonCircle","CollideEdgeCircle","edgeA","Q","e","A1","B1","e1","B2","A2","e2","den","n","chain","CollideEdgePolygon","e_edgeA","e_edgeB","EPAxis","edgeAxis","polygonAxis","polygonBA","rf","i1","i2","sideNormal1","sideOffset1","sideNormal2","sideOffset2","polygonB","centroidB","m_centroid","v0","v3","hasVertex0","hasVertex3","edge1","front","normal1","offset1","offset0","offset2","convex1","convex2","edge0","normal0","edge2","normal2","lowerLimit","upperLimit","primaryAxis","ie","clipPoints1","clipPoints2","FindMaxSeparation","poly1","poly2","count1","count2","n1s","v1s","v2s","maxSeparation","si","sij","_maxSeparation","_bestIndex","polyA","polyB","separationA","edgeB","separationB","flip","incidentEdge","normals1","vertices2","normals2","minDot","FindIncidentEdge","vertices1","iv1","iv2","v11","v12","localTangent","frontOffset","vertex1","vertex2","vertex0","vertex3","setPrev","setNext","_set","numerator","denominator","ps","unique","i0","x0","hull","ih","vs","pRef","inv3","p3","triangleArea","ComputeCentroid","pLocal","minX","minY","maxX","maxY","k_inv3","ex1","ey1","ex2","ey2","_list","_max","_createFn","_outFn","_inFn","_discardFn","discard","_createCount","_outCount","_inCount","_discardCount","size","item","Date","console","log","arguments","statement","err","propertyIsEnumerable","defaults","getOwnPropertySymbols","symbols","symbol"],"sourceRoot":""}