text: YUI.add('node-screen', function(Y) {
  
  /**
   * 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 {Int}
       */
      'winWidth',
  
      /**
       * Returns the inner height of the viewport (exludes scrollbar). 
       * @config winHeight
       * @type {Int}
       */
      'winHeight',
  
      /**
       * Document width 
       * @config docWidth
       * @type {Int}
       */
      'docWidth',
  
      /**
       * Document height 
       * @config docHeight
       * @type {Int}
       */
      'docHeight',
  
      /**
       * Pixel distance the page has been scrolled horizontally 
       * @config docScrollX
       * @type {Int}
       */
      'docScrollX',
  
      /**
       * Pixel distance the page has been scrolled vertically 
       * @config docScrollY
       * @type {Int}
       */
      '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.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.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 {Int} 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 {Int} 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 {Int} 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 {Int} 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'
  ]);
  
  /**
   * @module node
   * @submodule node-screen
   */
  
  /**
   * Returns a region object for the node
   * @config region
   * @for Node
   * @type Node
   */
  Y.Node.ATTRS.region = {
      getter: function() {
          var node = this.getDOMNode(),
              region;
  
          if (node && !node.tagName) {
              if (node.nodeType === 9) { // document
                  node = node.documentElement;
              }
          }
          if (Y.DOM.isWindow(node)) {
              region = Y.DOM.viewportRegion(node);
          } else {
              region = Y.DOM.region(node);
          }
          return region;
      }
  };
  
  /**
   * Returns a region object for the node's viewport
   * @config viewportRegion
   * @type Node
   */
  Y.Node.ATTRS.viewportRegion = {
      getter: function() {
          return Y.DOM.viewportRegion(Y.Node.getDOMNode(this));
      }
  };
  
  Y.Node.importMethod(Y.DOM, 'inViewportRegion');
  
  // these need special treatment to extract 2nd node arg
  /**
   * Compares the intersection of the node with another node or region
   * @method intersect
   * @for Node
   * @param {Node|Object} node2 The node or region to compare with.
   * @param {Object} altRegion An alternate region to use (rather than this node's).
   * @return {Object} An object representing the intersection of the regions.
   */
  Y.Node.prototype.intersect = function(node2, altRegion) {
      var node1 = Y.Node.getDOMNode(this);
      if (Y.instanceOf(node2, Y.Node)) { // might be a region object
          node2 = Y.Node.getDOMNode(node2);
      }
      return Y.DOM.intersect(node1, node2, altRegion);
  };
  
  /**
   * Determines whether or not the node is within the giving region.
   * @method inRegion
   * @param {Node|Object} node2 The node or region to compare with.
   * @param {Boolean} all Whether or not all of the node must be in the region.
   * @param {Object} altRegion An alternate region to use (rather than this node's).
   * @return {Object} An object representing the intersection of the regions.
   */
  Y.Node.prototype.inRegion = function(node2, all, altRegion) {
      var node1 = Y.Node.getDOMNode(this);
      if (Y.instanceOf(node2, Y.Node)) { // might be a region object
          node2 = Y.Node.getDOMNode(node2);
      }
      return Y.DOM.inRegion(node1, node2, all, altRegion);
  };
  
  
  }, '@VERSION@' ,{requires:['node-base', 'dom-screen']});
  