      * (0, 0) representing the rectangle's top-left corner, to (1, 1)
      * representing the bottom-right.
      *
-     * @param rect   The input rectangle.
-     * @param xParam The X parameter, with 0 representing the rectangle's left,
-     *               1 the right.
-     * @param yParam The Y parameter, with 0 representing the rectangle's top,
-     *               1 the bottom.
-     * @param out    An optional instance to store the result in.  If not
-     *               provided, a new Point is created.
-     *
-     * @return  The object containing the point.
+     * @param rect
+     * The input rectangle.
+     *
+     * @param xParam
+     * The X parameter, with 0 representing the rectangle's left, 1 the right.
+     *
+     * @param yParam
+     * The Y parameter, with 0 representing the rectangle's top, 1 the bottom.
+     *
+     * @param outPoint
+     * An optional instance to store the result in.  If not provided, a new
+     * Point is created.
+     *
+     * @return
+     * The object containing the point.
      */
     public static function getNormalizedPoint(
-        rect:*, xParam:Number, yParam:Number, out:* = null):*
-    {
-        if (!out) out = new Point();
-        out.x = rect.x + xParam * rect.width;
-        out.y = rect.y + yParam * rect.height;
-        return out;
+        rect:*, xParam:Number, yParam:Number, outPoint:* = null):*
+    {
+        if (!outPoint) outPoint = new Point();
+        outPoint.x = rect.x + xParam * rect.width;
+        outPoint.y = rect.y + yParam * rect.height;
+        return outPoint;
     }
 
 

     * Scales a source rectangle to fit or fill a target rectangle, maintaining
     * the source rectangle's aspect ratio.
     *
     * @param source   The source rectangle.
     * @param target   The rectangle to fit <code>source</code> into.
     * @param mode     Calculation mode: <code>INSIDE</code> calculating a
     *                 result that fits entirely within the target rectangle,
     *                 <code>OUTSIDE</code> calculating a result that covers
     *                 the entirety of the target rectangle.
     * @param xAlign   X alignment. A number from 0 to 1. 0 aligns left
     *                 edges, 1 aligns right edges, and 0.5 centres
     *                 horizontally. Other values interpolate between these
     *                 values.
     * @param yAlign   Y alignment. A number from 0 to 1. 0 aligns top
     *                 edges, 1 aligns bottom edges, and 0.5 centres
     *                 vertically. Other values interpolate between these
     *                 values.
     * @param rounding Rounds the calculated values of <code>x</code>,
     *                 <code>y</code>, <code>width</code> and
     *                 <code>height</code> to the nearest whole number.
     * @param out      An optional instance to store the result in.  If not
     *                 provided, a new Rectangle is created.
     *
     * @return  The object containing the result of fitting <code>source</code>
     *          to <code>target</code>.
     */
    public static function fit(source:*, target:*,
                                   fitMode:String,
                                   xAlign:Number = 0.5,
                                   yAlign:Number = 0.5,
                                   rounding:Boolean = false,
                                   out:* = null):*
    {
        // copy values to guard against aliasing
        var sw:Number = source.width, sh:Number = source.height;
        var tw:Number = target.width, th:Number = target.height;

        var scale:Number;

        if (!out) out = new Rectangle();

        if (fitMode == FitMode.OUTSIDE)
        {

    /**
     * Multiplies each coordinate in a rectangle by a scalar value.
     *
     * @param rect
     * The rectangle-like object to scale.
     *
     * @param factor
     * The factor to scale by.
     *
     * @param outRect
     * An optional instance to store the result in.  If not provided, a new
     * Rectangle is created.
     *
     * @return
     * The object containing the scaled rectangle.
     */
    public static function multiply(
        rect:*, factor:Number, outRect:* = null):*
    {
        if (!outRect) outRect = new Rectangle();
        outRect.x = rect.x * factor;
        outRect.y = rect.y * factor;
        outRect.width = rect.width * factor;
        outRect.height = rect.height * factor;
        return outRect;
    }


