/**
                             * Extended Node interface for managing regions and screen positioning.
                             * Adds support for positioning elements and normalizes window size and scroll detection.
                             * @module node
                             * @submodule node-screen
                             */
                            
                            // these are all "safe" returns, no wrapping required
                            Y.each([
                                /**
                                 * Returns the inner width of the viewport (exludes scrollbar).
                                 * @config winWidth
                                 * @for Node
                                 * @type {Number}
                                 */
                                'winWidth',
                            
                                /**
                                 * Returns the inner height of the viewport (exludes scrollbar).
                                 * @config winHeight
                                 * @type {Number}
                                 */
                                'winHeight',
                            
                                /**
                                 * Document width
                                 * @config docWidth
                                 * @type {Number}
                                 */
                                'docWidth',
                            
                                /**
                                 * Document height
                                 * @config docHeight
                                 * @type {Number}
                                 */
                                'docHeight',
                            
                                /**
                                 * Pixel distance the page has been scrolled horizontally
                                 * @config docScrollX
                                 * @type {Number}
                                 */
                                'docScrollX',
                            
                                /**
                                 * Pixel distance the page has been scrolled vertically
                                 * @config docScrollY
                                 * @type {Number}
                                 */
                                'docScrollY'
                                ],
                                function(name) {
                                    Y.Node.ATTRS[name] = {
                                        getter: function() {
                                            var args = Array.prototype.slice.call(arguments);
                                            args.unshift(Y.Node.getDOMNode(this));
                            
                                            return Y.DOM[name].apply(this, args);
                                        }
                                    };
                                }
                            );
                            
                            Y.Node.ATTRS.scrollLeft = {
                                getter: function() {
                                    var node = Y.Node.getDOMNode(this);
                                    return ('scrollLeft' in node) ? node.scrollLeft : Y.DOM.docScrollX(node);
                                },
                            
                                setter: function(val) {
                                    var node = Y.Node.getDOMNode(this);
                                    if (node) {
                                        if ('scrollLeft' in node) {
                                            node.scrollLeft = val;
                                        } else if (node.document || node.nodeType === 9) {
                                            Y.DOM._getWin(node).scrollTo(val, Y.DOM.docScrollY(node)); // scroll window if win or doc
                                        }
                                    } else {
                                        Y.log('unable to set scrollLeft for ' + node, 'error', 'Node');
                                    }
                                }
                            };
                            
                            Y.Node.ATTRS.scrollTop = {
                                getter: function() {
                                    var node = Y.Node.getDOMNode(this);
                                    return ('scrollTop' in node) ? node.scrollTop : Y.DOM.docScrollY(node);
                                },
                            
                                setter: function(val) {
                                    var node = Y.Node.getDOMNode(this);
                                    if (node) {
                                        if ('scrollTop' in node) {
                                            node.scrollTop = val;
                                        } else if (node.document || node.nodeType === 9) {
                                            Y.DOM._getWin(node).scrollTo(Y.DOM.docScrollX(node), val); // scroll window if win or doc
                                        }
                                    } else {
                                        Y.log('unable to set scrollTop for ' + node, 'error', 'Node');
                                    }
                                }
                            };
                            
                            Y.Node.importMethod(Y.DOM, [
                            /**
                             * Gets the current position of the node in page coordinates.
                             * @method getXY
                             * @for Node
                             * @return {Array} The XY position of the node
                            */
                                'getXY',
                            
                            /**
                             * Set the position of the node in page coordinates, regardless of how the node is positioned.
                             * @method setXY
                             * @param {Array} xy Contains X & Y values for new position (coordinates are page-based)
                             * @chainable
                             */
                                'setXY',
                            
                            /**
                             * Gets the current position of the node in page coordinates.
                             * @method getX
                             * @return {Number} The X position of the node
                            */
                                'getX',
                            
                            /**
                             * Set the position of the node in page coordinates, regardless of how the node is positioned.
                             * @method setX
                             * @param {Number} x X value for new position (coordinates are page-based)
                             * @chainable
                             */
                                'setX',
                            
                            /**
                             * Gets the current position of the node in page coordinates.
                             * @method getY
                             * @return {Number} The Y position of the node
                            */
                                'getY',
                            
                            /**
                             * Set the position of the node in page coordinates, regardless of how the node is positioned.
                             * @method setY
                             * @param {Number} y Y value for new position (coordinates are page-based)
                             * @chainable
                             */
                                'setY',
                            
                            /**
                             * Swaps the XY position of this node with another node.
                             * @method swapXY
                             * @param {Node | HTMLElement} otherNode The node to swap with.
                             * @chainable
                             */
                                'swapXY'
                            ]);