text: /**
  * The `Matter.Bounds` module contains methods for creating and manipulating axis-aligned bounding boxes (AABB).
  *
  * @class Bounds
  */
  
  var Bounds = {};
  
  module.exports = Bounds;
  
  (function() {
  
      /**
       * Creates a new axis-aligned bounding box (AABB) for the given vertices.
       * @method create
       * @param {vertices} vertices
       * @return {bounds} A new bounds object
       */
      Bounds.create = function(vertices) {
          var bounds = {
              min: { x: 0, y: 0 },
              max: { x: 0, y: 0 }
          };
  
          if (vertices)
              Bounds.update(bounds, vertices);
  
          return bounds;
      };
  
      /**
       * Updates bounds using the given vertices and extends the bounds given a velocity.
       * @method update
       * @param {bounds} bounds
       * @param {vertices} vertices
       * @param {vector} velocity
       */
      Bounds.update = function(bounds, vertices, velocity) {
          bounds.min.x = Infinity;
          bounds.max.x = -Infinity;
          bounds.min.y = Infinity;
          bounds.max.y = -Infinity;
  
          for (var i = 0; i < vertices.length; i++) {
              var vertex = vertices[i];
              if (vertex.x > bounds.max.x) bounds.max.x = vertex.x;
              if (vertex.x < bounds.min.x) bounds.min.x = vertex.x;
              if (vertex.y > bounds.max.y) bounds.max.y = vertex.y;
              if (vertex.y < bounds.min.y) bounds.min.y = vertex.y;
          }
  
          if (velocity) {
              if (velocity.x > 0) {
                  bounds.max.x += velocity.x;
              } else {
                  bounds.min.x += velocity.x;
              }
  
              if (velocity.y > 0) {
                  bounds.max.y += velocity.y;
              } else {
                  bounds.min.y += velocity.y;
              }
          }
      };
  
      /**
       * Returns true if the bounds contains the given point.
       * @method contains
       * @param {bounds} bounds
       * @param {vector} point
       * @return {boolean} True if the bounds contain the point, otherwise false
       */
      Bounds.contains = function(bounds, point) {
          return point.x >= bounds.min.x && point.x <= bounds.max.x
                 && point.y >= bounds.min.y && point.y <= bounds.max.y;
      };
  
      /**
       * Returns true if the two bounds intersect.
       * @method overlaps
       * @param {bounds} boundsA
       * @param {bounds} boundsB
       * @return {boolean} True if the bounds overlap, otherwise false
       */
      Bounds.overlaps = function(boundsA, boundsB) {
          return (boundsA.min.x <= boundsB.max.x && boundsA.max.x >= boundsB.min.x
                  && boundsA.max.y >= boundsB.min.y && boundsA.min.y <= boundsB.max.y);
      };
  
      /**
       * Translates the bounds by the given vector.
       * @method translate
       * @param {bounds} bounds
       * @param {vector} vector
       */
      Bounds.translate = function(bounds, vector) {
          bounds.min.x += vector.x;
          bounds.max.x += vector.x;
          bounds.min.y += vector.y;
          bounds.max.y += vector.y;
      };
  
      /**
       * Shifts the bounds to the given position.
       * @method shift
       * @param {bounds} bounds
       * @param {vector} position
       */
      Bounds.shift = function(bounds, position) {
          var deltaX = bounds.max.x - bounds.min.x,
              deltaY = bounds.max.y - bounds.min.y;
  
          bounds.min.x = position.x;
          bounds.max.x = position.x + deltaX;
          bounds.min.y = position.y;
          bounds.max.y = position.y + deltaY;
      };
  
  })();
  