      * with the restriction that its <code>b</code> and <code>c</code>
      * properties are fixed at zero.
      *
-     * @param rect     The rectangle-like object to transform.
-     * @param xFactor  The number to multiply the x and width by.  This is
-     *                 equivalent to a Matrix's <code>a</code> property.
-     * @param yFactor  The number to multiply the y and height by.  This is
-     *                 equivalent to a Matrix's <code>d</code> property.
-     * @param xOffset  The number to add to the resultant x.  This is
-     *                 equivalent to a Matrix's <code>tx</code> property.
-     * @param yOffset  The number to add to the resultant y.  This is
-     *                 equivalent to a Matrix's <code>ty</code> property.
-     * @param out      An optional instance to store the result in.  If not
-     *                 provided, a new Rectangle is created.
-     *
-     * @return  The object containing the transformed rectangle.
+     * @param rect
+     * The rectangle-like object to transform.
+     *
+     * @param xFactor
+     * The number to multiply the x and width by.  This is equivalent to a
+     * Matrix's <code>a</code> property.
+     *
+     * @param yFactor
+     * The number to multiply the y and height by.  This is equivalent to a
+     * Matrix's <code>d</code> property.
+     *
+     * @param xOffset
+     * The number to add to the resultant x.  This is equivalent to a Matrix's
+     * <code>tx</code> property.
+     *
+     * @param yOffset
+     * The number to add to the resultant y.  This is equivalent to a Matrix's
+     * <code>ty</code> property.
+     *
+     * @param outRect
+     * An optional instance to store the result in.  If not provided, a new
+     * Rectangle is created.
+     *
+     * @return
+     * The object containing the transformed rectangle.
      */
     public static function transform(
         rect:*,
         xFactor:Number, yFactor:Number,
         xOffset:Number, yOffset:Number,
-        out:* = null):*
-    {
-        if (!out) out = new Rectangle();
-        out.x = rect.x * xFactor + xOffset;
-        out.y = rect.y * yFactor + yOffset;
-        out.width = rect.width * xFactor;
-        out.height = rect.height * yFactor;
-        return out;
+        outRect:* = null):*
+    {
+        if (!outRect) outRect = new Rectangle();
+        outRect.x = rect.x * xFactor + xOffset;
+        outRect.y = rect.y * yFactor + yOffset;
+        outRect.width = rect.width * xFactor;
+        outRect.height = rect.height * yFactor;
+        return outRect;
     }
 
 

     * Scales a rectangle to have a specified area, maintaining its aspect
     * ratio.
     *
     * @param rect  The rectangle to scale.
     * @param area  The desired area.
     * @param out   An optional instance to store the result in.  If not
     *              provided, a new Rectangle is created.
     *
     * @return  The object containing the rectangle with the desired area.
     */
    public static function scaleToArea(
        rect:*, area:Number, out:* = null):*
    {
        if (!out) out = new Rectangle();
        var areaRatio:Number = Math.sqrt(area / (rect.width * rect.height));
        out.x = rect.x;
        out.y = rect.y;
        out.width = rect.width * areaRatio;
        out.height = rect.height * areaRatio;
        return out;
    }
}
}

     * center.  The result is the smallest rectangle with integral coordinates
     * that can entirely contain the input rectangle.
     *
     * @param rect
     * The rectangle-like object to round.
     *
     * @param outRect
     * An optional instance to store the result in.  If not provided, a new
     * Rectangle is created.
     *
     * @return
     * The object containing the rectangle with integral coordinates.
     */
    public static function roundOut(
        rect:*, outRect:* = null):*
    {
        if (!outRect) outRect = new Rectangle();

        var r:Number = rect.x + rect.width;
        var b:Number = rect.y + rect.height;

        outRect.x = Math.floor(rect.x);
        outRect.y = Math.floor(rect.y);
        outRect.width = Math.ceil(r) - outRect.x;
        outRect.height = Math.ceil(b) - outRect.y;
        return outRect;
    }


