(function(Y) {
                            var TOP = 'top',
                                RIGHT = 'right',
                                BOTTOM = 'bottom',
                                LEFT = 'left',
                            
                                getOffsets = function(r1, r2) {
                                    var t = Math.max(r1[TOP], r2[TOP]),
                                        r = Math.min(r1[RIGHT], r2[RIGHT]),
                                        b = Math.min(r1[BOTTOM], r2[BOTTOM]),
                                        l = Math.max(r1[LEFT], r2[LEFT]),
                                        ret = {};
                            
                                    ret[TOP] = t;
                                    ret[RIGHT] = r;
                                    ret[BOTTOM] = b;
                                    ret[LEFT] = l;
                                    return ret;
                                },
                            
                                DOM = Y.DOM;
                            
                            Y.mix(DOM, {
                                /**
                                 * Returns an Object literal containing the following about this element: (top, right, bottom, left)
                                 * @for DOM
                                 * @method region
                                 * @param {HTMLElement} element The DOM element.
                                 * @return {Object} Object literal containing the following about this element: (top, right, bottom, left)
                                 */
                                region: function(node) {
                                    var xy = DOM.getXY(node),
                                        ret = false;
                            
                                    if (node && xy) {
                                        ret = DOM._getRegion(
                                            xy[1], // top
                                            xy[0] + node.offsetWidth, // right
                                            xy[1] + node.offsetHeight, // bottom
                                            xy[0] // left
                                        );
                                    }
                            
                                    return ret;
                                },
                            
                                /**
                                 * Find the intersect information for the passed nodes.
                                 * @method intersect
                                 * @for DOM
                                 * @param {HTMLElement} element The first element
                                 * @param {HTMLElement | Object} element2 The element or region to check the interect with
                                 * @param {Object} altRegion An object literal containing the region for the first element if we already have the data (for performance e.g. DragDrop)
                                 * @return {Object} Object literal containing the following intersection data: (top, right, bottom, left, area, yoff, xoff, inRegion)
                                 */
                                intersect: function(node, node2, altRegion) {
                                    var r = altRegion || DOM.region(node), region = {},
                                        n = node2,
                                        off;
                            
                                    if (n.tagName) {
                                        region = DOM.region(n);
                                    } else if (Y.Lang.isObject(node2)) {
                                        region = node2;
                                    } else {
                                        return false;
                                    }
                            
                                    off = getOffsets(region, r);
                                    return {
                                        top: off[TOP],
                                        right: off[RIGHT],
                                        bottom: off[BOTTOM],
                                        left: off[LEFT],
                                        area: ((off[BOTTOM] - off[TOP]) * (off[RIGHT] - off[LEFT])),
                                        yoff: ((off[BOTTOM] - off[TOP])),
                                        xoff: (off[RIGHT] - off[LEFT]),
                                        inRegion: DOM.inRegion(node, node2, false, altRegion)
                                    };
                            
                                },
                                /**
                                 * Check if any part of this node is in the passed region
                                 * @method inRegion
                                 * @for DOM
                                 * @param {Object} node The node to get the region from
                                 * @param {Object} node2 The second node to get the region from or an Object literal of the region
                                 * @param {Boolean} all Should all of the node be inside the region
                                 * @param {Object} altRegion An object literal containing the region for this node if we already have the data (for performance e.g. DragDrop)
                                 * @return {Boolean} True if in region, false if not.
                                 */
                                inRegion: function(node, node2, all, altRegion) {
                                    var region = {},
                                        r = altRegion || DOM.region(node),
                                        n = node2,
                                        off;
                            
                                    if (n.tagName) {
                                        region = DOM.region(n);
                                    } else if (Y.Lang.isObject(node2)) {
                                        region = node2;
                                    } else {
                                        return false;
                                    }
                            
                                    if (all) {
                                        return (
                                            r[LEFT]   >= region[LEFT]   &&
                                            r[RIGHT]  <= region[RIGHT]  &&
                                            r[TOP]    >= region[TOP]    &&
                                            r[BOTTOM] <= region[BOTTOM]  );
                                    } else {
                                        off = getOffsets(region, r);
                                        if (off[BOTTOM] >= off[TOP] && off[RIGHT] >= off[LEFT]) {
                                            return true;
                                        } else {
                                            return false;
                                        }
                            
                                    }
                                },
                            
                                /**
                                 * Check if any part of this element is in the viewport
                                 * @method inViewportRegion
                                 * @for DOM
                                 * @param {HTMLElement} element The DOM element.
                                 * @param {Boolean} all Should all of the node be inside the region
                                 * @param {Object} altRegion An object literal containing the region for this node if we already have the data (for performance e.g. DragDrop)
                                 * @return {Boolean} True if in region, false if not.
                                 */
                                inViewportRegion: function(node, all, altRegion) {
                                    return DOM.inRegion(node, DOM.viewportRegion(node), all, altRegion);
                            
                                },
                            
                                _getRegion: function(t, r, b, l) {
                                    var region = {};
                            
                                    region[TOP] = region[1] = t;
                                    region[LEFT] = region[0] = l;
                                    region[BOTTOM] = b;
                                    region[RIGHT] = r;
                                    region.width = region[RIGHT] - region[LEFT];
                                    region.height = region[BOTTOM] - region[TOP];
                            
                                    return region;
                                },
                            
                                /**
                                 * Returns an Object literal containing the following about the visible region of viewport: (top, right, bottom, left)
                                 * @method viewportRegion
                                 * @for DOM
                                 * @return {Object} Object literal containing the following about the visible region of the viewport: (top, right, bottom, left)
                                 */
                                viewportRegion: function(node) {
                                    node = node || Y.config.doc.documentElement;
                                    var ret = false,
                                        scrollX,
                                        scrollY;
                            
                                    if (node) {
                                        scrollX = DOM.docScrollX(node);
                                        scrollY = DOM.docScrollY(node);
                            
                                        ret = DOM._getRegion(scrollY, // top
                                            DOM.winWidth(node) + scrollX, // right
                                            scrollY + DOM.winHeight(node), // bottom
                                            scrollX); // left
                                    }
                            
                                    return ret;
                                }
                            });
                            })(Y);