docs: function( options ){
  
              var self = this;
              var vector = Physics.vector;
  
              /** related to: Physics.util.options
               * Body#options( options ) -> Object
               * - options (Object): The options to set as an object
               * + (Object): The options
               *
               * Set options on this instance.
               *
               * Access options directly from the options object.
               *
               * Example:
               *
               * ```javascript
               * this.options.someOption;
               * ```
               *
               **/
              // all options get copied onto the body.
              this.options = Physics.util.options( defaults, this );
              this.options.onChange(function( opts ){
                  self.offset = new vector( opts.offset );
              });
              this.options( options );
  
              /**
               * Body#state
               *
               * The physical state container.
               *
               * - ``this.state.pos`` ([[Physics.vector]]) The position vector.
               * - ``this.state.vel`` ([[Physics.vector]]) The velocity vector.
               * - ``this.state.acc`` ([[Physics.vector]]) The acceleration vector.
               * - ``this.state.angular.pos`` ([[Number]]) The angular position (in radians, positive is clockwise starting along the x axis)
               * - ``this.state.angular.vel`` ([[Number]]) The angular velocity
               * - ``this.state.angular.acc`` ([[Number]]) The angular acceleration
               *
               * Properties from the previous timestep are stored in:
               * ```javascript
               * this.state.old; // .pos, .vel, ...
               * ```
               **/
              this.state = {
                  pos: new vector( this.x, this.y ),
                  vel: new vector( this.vx, this.vy ),
                  acc: new vector(),
                  angular: {
                      pos: this.angle || 0.0,
                      vel: this.angularVelocity || 0.0,
                      acc: 0.0
                  },
                  old: {
                      pos: new vector(),
                      vel: new vector(),
                      acc: new vector(),
                      angular: {
                          pos: 0.0,
                          vel: 0.0,
                          acc: 0.0
                      }
                  }
              };
  
              // private storage for sleeping
              this._sleepAngPosMean = 0;
              this._sleepAngPosVariance = 0;
              this._sleepPosMean = new vector();
              this._sleepPosVariance = new vector();
              this._sleepMeanK = 0;
  
              // cleanup
              delete this.x;
              delete this.y;
              delete this.vx;
              delete this.vy;
              delete this.angle;
              delete this.angularVelocity;
  
              if (this.mass === 0){
                  throw "Error: Bodies must have non-zero mass";
              }
  
              /**
               * Body#uid = Number
               *
               * The unique id for the body
               **/
              this.uid = uidGen++;
  
              /** related to: Physics.geometry
               * Body#geometry
               *
               * The geometry for this body.
               *
               * By default it is a `point` geometry which gets overridden.
               **/
              this.geometry = Physics.geometry('point');
  
              /**
               * Body#mass = 1.0
               *
               * The mass.
               **/
  
              /**
               * Body#offset
               *
               * The vector offsetting the body's shape from its center of mass.
               **/
  
               /**
                * Body#restitution = 1.0
                *
                * The restitution.
                *
                * This is the "bounciness" of the body.
                * It's a number between `0` and `1`.
                *
                * A restitution of 1 is the bounciest.
                *
                * A restitution of 0 is not bouncy.
                *
                * When colliding the restitutions of bodies are
                * multiplied together to get the restitution between two
                * bodies.
                *
                **/
  
                /**
                 * Body#cof = 0.8
                 *
                 * The coefficient of friction of the body.
                 *
                 * It's how much "slide" it has during collisions.
                 *
                 * A `cof` of `0` will really slidy.
                 *
                 * A `cof` of `1` has no slide.
                 *
                 * This is a very simplistic implementation at the moment.
                 * What would be better is to have both static and kinetic
                 * friction. But that's not done yet.
                 **/
  
                 /**
                  * Body#treatment = String
                  *
                  * How the body is treated by the simulation.
                  *
                  * The body can be `dynamic`, `kinematic` or `static` as
                  * described by the [analogous box2d docs](http://www.box2d.org/manual.html#_Toc258082973).
                  *
                  * * _dynamic_ bodies are treated "normally". They are integrated, and collide, and all that.
                  * * _kinematic_ bodies are bodies that move at a specified velocity. Other bodies collide with them, but they don't bounce off of other bodies.
                  * * _static_ bodies just stand still. They are like obstacles.
                  **/
  
                  /**
                   * Body#hidden = false
                   *
                   * Determines whether the body should be hidden by the renderer.
                   **/
  
                  /** related to: Physics.renderer
                   * Body#view = it_depends
                   *
                   * Storage for use by the renderer.
                   *
                   * The type of renderer will put different things in the view property.
                   * Basically, this is how the body "looks". It could be a HTMLElement, or
                   * an Image, etc...
                   *
                   * If your body changes appearance (shape), you should modify this somehow
                   * otherwise the renderer will keep using this same view. If you're letting
                   * the renderer create the view for you, just set this to `undefined` if the
                   * body gets modified in shape during the simulation.
                   **/
  
                  /** related to: Physics.renderer
                   * Body#styles
                   *
                   * The styles the renderer should use for creating the view.
                   *
                   * The styles depend on the renderer. See [[Renderer#createView]] for style options.
                   **/
          }