--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/cm/media/js/lib/yui/yui_3.0.0b1/build/node/node.js Mon Nov 23 15:14:29 2009 +0100
@@ -0,0 +1,1839 @@
+/*
+Copyright (c) 2009, Yahoo! Inc. All rights reserved.
+Code licensed under the BSD License:
+http://developer.yahoo.net/yui/license.txt
+version: 3.0.0b1
+build: 1163
+*/
+YUI.add('node-base', function(Y) {
+
+/**
+ * The Node Utility provides a DOM-like interface for interacting with DOM nodes.
+ * @module node
+ * @submodule node-base
+ */
+
+/**
+ * The Node class provides a wrapper for manipulating DOM Nodes.
+ * Node properties can be accessed via the set/get methods.
+ * Use Y.get() to retrieve Node instances.
+ *
+ * <strong>NOTE:</strong> Node properties are accessed using
+ * the <code>set</code> and <code>get</code> methods.
+ *
+ * @class Node
+ * @constructor
+ * @for Node
+ */
+
+// "globals"
+var g_nodes = {},
+ g_nodelists = {},
+ g_restrict = {},
+ g_slice = Array.prototype.slice,
+
+ DOT = '.',
+ NODE_NAME = 'nodeName',
+ NODE_TYPE = 'nodeType',
+ OWNER_DOCUMENT = 'ownerDocument',
+ TAG_NAME = 'tagName',
+ UID = '_yuid',
+
+ SuperConstr = Y.Base,
+ SuperConstrProto = Y.Base.prototype,
+
+ Node = function(node, restricted) {
+ var config = null;
+ this[UID] = Y.stamp(node);
+ if (!this[UID]) { // stamp failed; likely IE non-HTMLElement
+ this[UID] = Y.guid();
+ }
+
+ g_nodes[this[UID]] = node;
+ Node._instances[this[UID]] = this;
+
+ if (restricted) {
+ config = {
+ restricted: restricted
+ };
+ g_restrict[this[UID]] = true;
+ }
+
+ this._lazyAttrInit = true;
+ this._silentInit = true;
+ SuperConstr.call(this, config);
+ },
+
+ // used with previous/next/ancestor tests
+ _wrapFn = function(fn) {
+ var ret = null;
+ if (fn) {
+ ret = (typeof fn === 'string') ?
+ function(n) {
+ return Y.Selector.test(n, fn);
+ } :
+ function(n) {
+ return fn(Node.get(n));
+ };
+ }
+
+ return ret;
+ };
+// end "globals"
+
+Node.NAME = 'Node';
+
+Node.DOM_EVENTS = {
+ abort: true,
+ blur: true,
+ change: true,
+ click: true,
+ close: true,
+ command: true,
+ contextmenu: true,
+ drag: true,
+ dragstart: true,
+ dragenter: true,
+ dragover: true,
+ dragleave: true,
+ dragend: true,
+ drop: true,
+ dblclick: true,
+ error: true,
+ focus: true,
+ keydown: true,
+ keypress: true,
+ keyup: true,
+ load: true,
+ mousedown: true,
+ mousemove: true,
+ mouseout: true,
+ mouseover: true,
+ mouseup: true,
+ mousemultiwheel: true,
+ mousewheel: true,
+ submit: true,
+ mouseenter: true,
+ mouseleave: true,
+ scroll: true,
+ reset: true,
+ resize: true,
+ select: true,
+ textInput: true,
+ unload: true
+};
+
+// Add custom event adaptors to this list. This will make it so
+// that delegate, key, available, contentready, etc all will
+// be available through Node.on
+Y.mix(Node.DOM_EVENTS, Y.Env.evt.plugins);
+
+Node._instances = {};
+
+/**
+ * Registers plugins to be instantiated at the class level (plugins
+ * which should be plugged into every instance of Node by default).
+ *
+ * @method Node.plug
+ * @static
+ *
+ * @param {Function | Array} plugin Either the plugin class, an array of plugin classes or an array of objects (with fn and cfg properties defined)
+ * @param {Object} config (Optional) If plugin is the plugin class, the configuration for the plugin
+ */
+Node.plug = function() {
+ var args = g_slice.call(arguments, 0);
+ args.unshift(Node);
+ Y.Base.plug.apply(Y.Base, args);
+ return Node;
+};
+
+/**
+ * Unregisters any class level plugins which have been registered by the Node
+ *
+ * @method Node.unplug
+ * @static
+ *
+ * @param {Function | Array} plugin The plugin class, or an array of plugin classes
+ */
+Node.unplug = function() {
+ var args = g_slice.call(arguments, 0);
+ args.unshift(Node);
+ Y.Base.unplug.apply(Y.Base, args);
+ return Node;
+};
+
+/**
+ * Retrieves the DOM node bound to a Node instance
+ * @method Node.getDOMNode
+ * @static
+ *
+ * @param {Y.Node || HTMLNode} node The Node instance or an HTMLNode
+ * @return {HTMLNode} The DOM node bound to the Node instance. If a DOM node is passed
+ * as the node argument, it is simply returned.
+ */
+Node.getDOMNode = function(node) {
+ if (node) {
+ if (node instanceof Node) {
+ node = g_nodes[node[UID]];
+ } else if (!node[NODE_NAME] || Y.DOM.isWindow(node)) { // must already be a DOMNode
+ node = null;
+ }
+ }
+ return node || null;
+};
+
+Node.scrubVal = function(val, node, depth) {
+ if (node && val) { // only truthy values are risky
+ if (typeof val === 'object' || typeof val === 'function') { // safari nodeList === function
+ if (NODE_TYPE in val || Y.DOM.isWindow(val)) {// node || window
+ if (g_restrict[node[UID]] && !node.contains(val)) {
+ val = null; // not allowed to go outside of root node
+ } else {
+ val = Node.get(val);
+ }
+ } else if (val.item || // dom collection or Node instance // TODO: check each node for restrict? block ancestor?
+ (val[0] && val[0][NODE_TYPE])) { // array of DOM Nodes
+ val = Y.all(val);
+ } else {
+ depth = (depth === undefined) ? 4 : depth;
+ if (depth > 0) {
+ for (var i in val) { // TODO: test this and pull hasOwnProperty check if safe?
+ if (val.hasOwnProperty && val.hasOwnProperty(i)) {
+ val[i] = Node.scrubVal(val[i], node, --depth);
+ }
+ }
+ }
+ }
+ }
+ } else if (val === undefined) {
+ val = node; // for chaining
+ }
+
+ return val;
+};
+
+Node.addMethod = function(name, fn, context) {
+ if (name && fn && typeof fn === 'function') {
+ Node.prototype[name] = function() {
+ context = context || this;
+ var args = g_slice.call(arguments),
+ ret;
+
+ if (args[0] && args[0] instanceof Node) {
+ args[0] = Node.getDOMNode(args[0]);
+ }
+
+ if (args[1] && args[1] instanceof Node) {
+ args[1] = Node.getDOMNode(args[1]);
+ }
+ args.unshift(g_nodes[this[UID]]);
+ ret = Node.scrubVal(fn.apply(context, args), this);
+ return ret;
+ };
+ } else {
+ }
+};
+
+Node.importMethod = function(host, name, altName) {
+ if (typeof name === 'string') {
+ altName = altName || name;
+ Node.addMethod(altName, host[name], host);
+ } else {
+ Y.each(name, function(n) {
+ Node.importMethod(host, n);
+ });
+ }
+};
+
+/**
+ * Returns a single Node instance bound to the node or the
+ * first element matching the given selector.
+ * @method Y.get
+ * @static
+ * @param {String | HTMLElement} node a node or Selector
+ * @param {Y.Node || HTMLElement} doc an optional document to scan. Defaults to Y.config.doc.
+ * @param {Boolean} restrict Whether or not the Node instance should be restricted to accessing
+ * its subtree only.
+ */
+Node.get = function(node, doc, restrict) {
+ var instance = null;
+
+ if (typeof node === 'string') {
+ if (node.indexOf('doc') === 0) { // doc OR document
+ node = Y.config.doc;
+ } else if (node.indexOf('win') === 0) { // doc OR document
+ node = Y.config.win;
+ } else {
+ node = Y.Selector.query(node, doc, true);
+ }
+ }
+
+ if (node) {
+ instance = Node._instances[node[UID]]; // reuse exising instances
+ if (!instance) {
+ instance = new Node(node, restrict);
+ } else if (restrict) {
+ g_restrict[instance[UID]] = true;
+ instance._set('restricted', true);
+ }
+ }
+ // TODO: restrict on subsequent call?
+ return instance;
+};
+
+/**
+ * Creates a new dom node using the provided markup string.
+ * @method create
+ * @static
+ * @param {String} html The markup used to create the element
+ * @param {HTMLDocument} doc An optional document context
+ */
+Node.create = function() {
+ return Node.get(Y.DOM.create.apply(Y.DOM, arguments));
+};
+
+Node.ATTRS = {
+ /**
+ * Allows for getting and setting the text of an element.
+ * Formatting is preserved and special characters are treated literally.
+ * @config text
+ * @type String
+ */
+ text: {
+ getter: function() {
+ return Y.DOM.getText(g_nodes[this[UID]]);
+ },
+
+ setter: function(content) {
+ Y.DOM.setText(g_nodes[this[UID]], content);
+ return content;
+ }
+ },
+
+ 'options': {
+ getter: function() {
+ return this.getElementsByTagName('option');
+ }
+ },
+
+ /**
+ * Returns a NodeList instance of all HTMLElement children.
+ * @readOnly
+ * @config children
+ * @type NodeList
+ */
+ 'children': {
+ getter: function() {
+ var node = g_nodes[this[UID]],
+ children = node.children,
+ childNodes, i, len;
+
+ if (children === undefined) {
+ childNodes = node.childNodes;
+ children = [];
+
+ for (i = 0, len = childNodes.length; i < len; ++i) {
+ if (childNodes[i][TAG_NAME]) {
+ children[children.length] = childNodes[i];
+ }
+ }
+ }
+ return Y.all(children);
+ }
+ },
+
+ value: {
+ getter: function() {
+ return Y.DOM.getValue(g_nodes[this[UID]]);
+ },
+
+ setter: function(val) {
+ Y.DOM.setValue(g_nodes[this[UID]], val);
+ return val;
+ }
+ },
+
+/*
+ style: {
+ getter: function(attr) {
+ return Y.DOM.getStyle(g_nodes[this[UID]].style, attr);
+ }
+ },
+*/
+
+ /**
+ * Whether or not this Node can traverse outside of its subtree.
+ * @config restricted
+ * @writeOnce
+ * @type Boolean
+ */
+ restricted: {
+ writeOnce: true,
+ value: false
+ }
+};
+
+// call with instance context
+Node.DEFAULT_SETTER = function(name, val) {
+ var node = g_nodes[this[UID]],
+ strPath;
+
+ if (name.indexOf(DOT) > -1) {
+ strPath = name;
+ name = name.split(DOT);
+ Y.Object.setValue(node, name, val);
+ } else if (node[name] !== undefined) { // only set DOM attributes
+ node[name] = val;
+ }
+
+ return val;
+};
+
+// call with instance context
+Node.DEFAULT_GETTER = function(name) {
+ var node = g_nodes[this[UID]],
+ val;
+
+ if (name.indexOf && name.indexOf(DOT) > -1) {
+ val = Y.Object.getValue(node, name.split(DOT));
+ } else {
+ val = node[name];
+ }
+
+ return val ? Y.Node.scrubVal(val, this) : val;
+};
+
+Y.extend(Node, Y.Base);
+
+Y.mix(Node.prototype, {
+ toString: function() {
+ var str = '',
+ errorMsg = this[UID] + ': not bound to a node',
+ node = g_nodes[this[UID]];
+
+ if (node) {
+ str += node[NODE_NAME];
+ if (node.id) {
+ str += '#' + node.id;
+ }
+
+ if (node.className) {
+ str += '.' + node.className.replace(' ', '.');
+ }
+
+ // TODO: add yuid?
+ str += ' ' + this[UID];
+ }
+ return str || errorMsg;
+ },
+
+ _addDOMAttr: function(attr) {
+ var domNode = g_nodes[this[UID]];
+
+ if (domNode && domNode[attr] !== undefined) {
+ this.addAttr(attr, {
+ getter: function() {
+ return Node.DEFAULT_GETTER.call(this, attr);
+ },
+
+ setter: function(val) {
+ return Node.DEFAULT_SETTER.call(this, attr, val);
+ }
+ });
+ } else {
+ }
+ },
+
+ get: function(attr) {
+ if (!this.attrAdded(attr)) { // use DEFAULT_GETTER for unconfigured attrs
+ if (Node.re_aria && Node.re_aria.test(attr)) { // except for aria
+ this._addAriaAttr(attr);
+ } else {
+ return Node.DEFAULT_GETTER.apply(this, arguments);
+ }
+ }
+
+ return SuperConstrProto.get.apply(this, arguments);
+ },
+
+ set: function(attr, val) {
+ if (!this.attrAdded(attr)) { // use DEFAULT_SETTER for unconfigured attrs
+ // except for aria
+ if (Node.re_aria && Node.re_aria.test(attr)) {
+ this._addAriaAttr(attr);
+ // or chained properties or if no change listeners
+ } else if (attr.indexOf(DOT) < 0 && this._yuievt.events['Node:' + attr + 'Change']) {
+ this._addDOMAttr(attr);
+ } else {
+ Node.DEFAULT_SETTER.call(this, attr, val);
+ return this; // NOTE: return
+ }
+ }
+ SuperConstrProto.set.apply(this, arguments);
+ return this;
+ },
+
+ /**
+ * Creates a new Node using the provided markup string.
+ * @method create
+ * @param {String} html The markup used to create the element
+ * @param {HTMLDocument} doc An optional document context
+ */
+ create: Node.create,
+
+ /**
+ * Compares nodes to determine if they match.
+ * Node instances can be compared to each other and/or HTMLElements.
+ * @method compareTo
+ * @param {HTMLElement | Node} refNode The reference node to compare to the node.
+ * @return {Boolean} True if the nodes match, false if they do not.
+ */
+ compareTo: function(refNode) {
+ var node = g_nodes[this[UID]];
+ if (refNode instanceof Y.Node) {
+ refNode = Y.Node.getDOMNode(refNode);
+ }
+ return node === refNode;
+ },
+
+ /**
+ * Determines whether the node is appended to the document.
+ * @method inDoc
+ * @param {Node|HTMLElement} doc optional An optional document to check against.
+ * Defaults to current document.
+ * @return {Boolean} Whether or not this node is appended to the document.
+ */
+ inDoc: function(doc) {
+ var node = g_nodes[this[UID]];
+ doc = (doc) ? Node.getDOMNode(doc) : node[OWNER_DOCUMENT];
+ if (doc.documentElement) {
+ return Y.DOM.contains(doc.documentElement, node);
+ }
+ },
+
+ getById: function(id) {
+ var node = g_nodes[this[UID]],
+ ret = Y.DOM.byId(id, node[OWNER_DOCUMENT]);
+ if (ret && Y.DOM.contains(node, ret)) {
+ ret = Y.get(ret);
+ } else {
+ ret = null;
+ }
+ return ret;
+ },
+
+ /**
+ * Returns the nearest ancestor that passes the test applied by supplied boolean method.
+ * @method ancestor
+ * @param {String | Function} fn A selector or boolean method for testing elements.
+ * If a function is used, it receives the current node being tested as the only argument.
+ * @return {Node} The matching Node instance or null if not found
+ */
+ ancestor: function(fn) {
+ return Node.get(Y.DOM.elementByAxis(g_nodes[this[UID]], 'parentNode', _wrapFn(fn)));
+ },
+
+ /**
+ * Returns the previous matching sibling.
+ * Returns the nearest element node sibling if no method provided.
+ * @method previous
+ * @param {String | Function} fn A selector or boolean method for testing elements.
+ * If a function is used, it receives the current node being tested as the only argument.
+ * @return {Node} Node instance or null if not found
+ */
+ previous: function(fn, all) {
+ return Node.get(Y.DOM.elementByAxis(g_nodes[this[UID]], 'previousSibling', _wrapFn(fn), all));
+ },
+
+ /**
+ * Returns the next matching sibling.
+ * Returns the nearest element node sibling if no method provided.
+ * @method next
+ * @param {String | Function} fn A selector or boolean method for testing elements.
+ * If a function is used, it receives the current node being tested as the only argument.
+ * @return {Node} Node instance or null if not found
+ */
+ next: function(node, fn, all) {
+ return Node.get(Y.DOM.elementByAxis(g_nodes[this[UID]], 'nextSibling', _wrapFn(fn), all));
+ },
+
+ /**
+ * Retrieves a Node instance of nodes based on the given CSS selector.
+ * @method query
+ *
+ * @param {string} selector The CSS selector to test against.
+ * @return {Node} A Node instance for the matching HTMLElement.
+ */
+ query: function(selector) {
+ return Y.get(Y.Selector.query(selector, g_nodes[this[UID]], true));
+ },
+
+ /**
+ * Retrieves a nodeList based on the given CSS selector.
+ * @method queryAll
+ *
+ * @param {string} selector The CSS selector to test against.
+ * @return {NodeList} A NodeList instance for the matching HTMLCollection/Array.
+ */
+ queryAll: function(selector) {
+ return Y.all(Y.Selector.query(selector, g_nodes[this[UID]]));
+ },
+
+ // TODO: allow fn test
+ /**
+ * Test if the supplied node matches the supplied selector.
+ * @method test
+ *
+ * @param {string} selector The CSS selector to test against.
+ * @return {boolean} Whether or not the node matches the selector.
+ */
+ test: function(selector) {
+ return Y.Selector.test(g_nodes[this[UID]], selector);
+ },
+
+ /**
+ * Removes the node from its parent.
+ * Shortcut for myNode.get('parentNode').removeChild(myNode);
+ * @method remove
+ * @chainable
+ *
+ */
+ remove: function() {
+ var node = g_nodes[this[UID]];
+ node.parentNode.removeChild(node);
+ return this;
+ },
+
+ /**
+ * Invokes a method on the Node instance
+ * @method invoke
+ * @param {String} method The name of the method to invoke
+ * @param {Any} a, b, c, etc. Arguments to invoke the method with.
+ * @return Whatever the underly method returns.
+ * DOM Nodes and Collections return values
+ * are converted to Node/NodeList instances.
+ *
+ */
+ invoke: function(method, a, b, c, d, e) {
+ var node = g_nodes[this[UID]],
+ ret;
+
+ if (a && a instanceof Y.Node) {
+ a = Node.getDOMNode(a);
+ }
+
+ if (b && b instanceof Y.Node) {
+ b = Node.getDOMNode(b);
+ }
+
+ ret = node[method](a, b, c, d, e);
+ return Y.Node.scrubVal(ret, this);
+ },
+
+ destructor: function() {
+ // TODO: What about shared instances?
+ //var uid = this[UID];
+
+ //delete g_nodes[uid];
+ //delete g_restrict[uid];
+ //delete Node._instances[uid];
+ },
+
+ /**
+ * Applies the given function to each Node in the NodeList.
+ * @method each
+ * @deprecated Use NodeList
+ * @param {Function} fn The function to apply
+ * @param {Object} context optional An optional context to apply the function with
+ * Default context is the NodeList instance
+ * @chainable
+ */
+ each: function(fn, context) {
+ context = context || this;
+ return fn.call(context, this);
+ },
+
+ /**
+ * Retrieves the Node instance at the given index.
+ * @method item
+ * @deprecated Use NodeList
+ *
+ * @param {Number} index The index of the target Node.
+ * @return {Node} The Node instance at the given index.
+ */
+ item: function(index) {
+ return this;
+ },
+
+ /**
+ * Returns the current number of items in the Node.
+ * @method size
+ * @deprecated Use NodeList
+ * @return {Int} The number of items in the Node.
+ */
+ size: function() {
+ return g_nodes[this[UID]] ? 1 : 0;
+ },
+
+ /**
+ * Inserts the content before the reference node.
+ * @method insert
+ * @param {String | Y.Node | HTMLElement} content The content to insert
+ * @param {Int | Y.Node | HTMLElement | String} where The position to insert at.
+ * @chainable
+ */
+ insert: function(content, where) {
+ if (content) {
+ if (typeof where === 'number') { // allow index
+ where = g_nodes[this[UID]].childNodes[where];
+ }
+ if (typeof content !== 'string') { // pass the DOM node
+ content = Y.Node.getDOMNode(content);
+ }
+ if (!where || // only allow inserting into this Node's subtree
+ (!g_restrict[this[UID]] ||
+ (typeof where !== 'string' && this.contains(where)))) {
+ Y.DOM.addHTML(g_nodes[this[UID]], content, where);
+ }
+ }
+ return this;
+ },
+
+ /**
+ * Inserts the content as the firstChild of the node.
+ * @method prepend
+ * @param {String | Y.Node | HTMLElement} content The content to insert
+ * @chainable
+ */
+ prepend: function(content) {
+ return this.insert(content, 0);
+ },
+
+ /**
+ * Inserts the content as the lastChild of the node.
+ * @method append
+ * @param {String | Y.Node | HTMLElement} content The content to insert
+ * @chainable
+ */
+ append: function(content) {
+ return this.insert(content, null);
+ },
+
+ /**
+ * Replaces the node's current content with the content.
+ * @method setContent
+ * @param {String | Y.Node | HTMLElement} content The content to insert
+ * @chainable
+ */
+ setContent: function(content) {
+ Y.DOM.addHTML(g_nodes[this[UID]], content, 'replace');
+ return this;
+ },
+
+ // TODO: need this?
+ hasMethod: function(method) {
+ var node = g_nodes[this[UID]];
+ return (node && (typeof node === 'function'));
+ }
+}, true);
+
+Y.Node = Node;
+Y.get = Y.Node.get;
+/**
+ * The NodeList module provides support for managing collections of Nodes.
+ * @module node
+ * @submodule nodelist
+ */
+
+/**
+ * The NodeList class provides a wrapper for manipulating DOM NodeLists.
+ * NodeList properties can be accessed via the set/get methods.
+ * Use Y.all() to retrieve NodeList instances.
+ *
+ * @class NodeList
+ * @constructor
+ */
+
+Y.Array._diff = function(a, b) {
+ var removed = [],
+ present = false,
+ i, j, lenA, lenB;
+
+ outer:
+ for (i = 0, lenA = a.length; i < lenA; i++) {
+ present = false;
+ for (j = 0, lenB = b.length; j < lenB; j++) {
+ if (a[i] === b[j]) {
+ present = true;
+ continue outer;
+ }
+ }
+ if (!present) {
+ removed[removed.length] = a[i];
+ }
+ }
+ return removed;
+};
+
+Y.Array.diff = function(a, b) {
+ return {
+ added: Y.Array._diff(b, a),
+ removed: Y.Array._diff(a, b)
+ };
+};
+
+var NodeList = function(config) {
+ var doc = config.doc || Y.config.doc,
+ nodes = config.nodes || [];
+
+ if (typeof nodes === 'string') {
+ this._query = nodes;
+ nodes = Y.Selector.query(nodes, doc);
+ }
+
+ Y.stamp(this);
+ NodeList._instances[this[UID]] = this;
+ g_nodelists[this[UID]] = nodes;
+
+ if (config.restricted) {
+ g_restrict = this[UID];
+ }
+};
+// end "globals"
+
+NodeList.NAME = 'NodeList';
+
+/**
+ * Retrieves the DOM nodes bound to a NodeList instance
+ * @method NodeList.getDOMNodes
+ * @static
+ *
+ * @param {Y.NodeList} node The NodeList instance
+ * @return {Array} The array of DOM nodes bound to the NodeList
+ */
+NodeList.getDOMNodes = function(nodeList) {
+ return g_nodelists[nodeList[UID]];
+};
+
+NodeList._instances = [];
+
+NodeList.each = function(instance, fn, context) {
+ var nodes = g_nodelists[instance[UID]];
+ if (nodes && nodes.length) {
+ Y.Array.each(nodes, fn, context || instance);
+ } else {
+ }
+};
+
+NodeList.addMethod = function(name, fn, context) {
+ var tmp = NodeList._getTempNode();
+ if (name && fn) {
+ NodeList.prototype[name] = function() {
+ var ret = [],
+ args = arguments;
+
+ Y.Array.each(g_nodelists[this[UID]], function(node) {
+ var UID = '_yuid',
+ instance = Y.Node._instances[node[UID]],
+ ctx,
+ result;
+
+ if (!instance) {
+ g_nodes[tmp[UID]] = node;
+ instance = tmp;
+ }
+ ctx = context || instance;
+ result = fn.apply(ctx, args);
+ if (result !== undefined && result !== instance) {
+ ret[ret.length] = result;
+ }
+ });
+
+ // TODO: remove tmp pointer
+ return ret.length ? ret : this;
+ };
+ } else {
+ }
+};
+
+NodeList.importMethod = function(host, name, altName) {
+ if (typeof name === 'string') {
+ altName = altName || name;
+ NodeList.addMethod(name, host[name]);
+ } else {
+ Y.each(name, function(n) {
+ NodeList.importMethod(host, n);
+ });
+ }
+};
+
+NodeList._getTempNode = function() {
+ var tmp = NodeList._tempNode;
+ if (!tmp) {
+ tmp = Y.Node.create('<div></div>');
+ NodeList._tempNode = tmp;
+ }
+ return tmp;
+};
+
+Y.mix(NodeList.prototype, {
+ /**
+ * Retrieves the Node instance at the given index.
+ * @method item
+ *
+ * @param {Number} index The index of the target Node.
+ * @return {Node} The Node instance at the given index.
+ */
+ item: function(index) {
+ return Y.get((g_nodelists[this[UID]] || [])[index]);
+ },
+
+ /**
+ * Applies the given function to each Node in the NodeList.
+ * @method each
+ * @param {Function} fn The function to apply. It receives 3 arguments:
+ * the current node instance, the node's index, and the NodeList instance
+ * @param {Object} context optional An optional context to apply the function with
+ * Default context is the current Node instance
+ * @chainable
+ */
+ each: function(fn, context) {
+ var instance = this;
+ Y.Array.each(g_nodelists[this[UID]], function(node, index) {
+ node = Y.get(node);
+ return fn.call(context || node, node, index, instance);
+ });
+ return instance;
+ },
+
+ batch: function(fn, context) {
+ var nodelist = this,
+ tmp = NodeList._getTempNode();
+
+ Y.Array.each(g_nodelists[this[UID]], function(node, index) {
+ var instance = Y.Node._instances[node[UID]];
+ if (!instance) {
+ g_nodes[tmp[UID]] = node;
+ instance = tmp;
+ }
+
+ return fn.call(context || instance, instance, index, nodelist);
+ });
+ return nodelist;
+ },
+
+ /**
+ * Executes the function once for each node until a true value is returned.
+ * @method some
+ * @param {Function} fn The function to apply. It receives 3 arguments:
+ * the current node instance, the node's index, and the NodeList instance
+ * @param {Object} context optional An optional context to execute the function from.
+ * Default context is the current Node instance
+ * @return {Boolean} Whether or not the function returned true for any node.
+ */
+ some: function(fn, context) {
+ var instance = this;
+ return Y.Array.some(g_nodelists[this[UID]], function(node, index) {
+ node = Y.get(node);
+ context = context || node;
+ return fn.call(context, node, index, instance);
+ });
+ },
+
+ /**
+ * Returns the index of the node in the NodeList instance
+ * or -1 if the node isn't found.
+ * @method indexOf
+ * @param {Y.Node || DOMNode} node the node to search for
+ * @return {Int} the index of the node value or -1 if not found
+ */
+ indexOf: function(node) {
+ return Y.Array.indexOf(g_nodelists[this[UID]], Y.Node.getDOMNode(node));
+ },
+
+ /**
+ * Filters the NodeList instance down to only nodes matching the given selector.
+ * @method filter
+ * @param {String} selector The selector to filter against
+ * @return {NodeList} NodeList containing the updated collection
+ * @see Selector
+ */
+ filter: function(selector) {
+ return Y.all(Y.Selector.filter(g_nodelists[this[UID]], selector));
+ },
+
+ modulus: function(n, r) {
+ r = r || 0;
+ var nodes = [];
+ NodeList.each(this, function(node, i) {
+ if (i % n === r) {
+ nodes.push(node);
+ }
+ });
+
+ return Y.all(nodes);
+ },
+
+ /**
+ * Creates a new NodeList containing all nodes at odd indices
+ * (zero-based index).
+ * @method odd
+ * @return {NodeList} NodeList containing the updated collection
+ */
+ odd: function() {
+ return this.modulus(2, 1);
+ },
+
+ /**
+ * Creates a new NodeList containing all nodes at even indices
+ * (zero-based index), including zero.
+ * @method even
+ * @return {NodeList} NodeList containing the updated collection
+ */
+ even: function() {
+ return this.modulus(2);
+ },
+
+ destructor: function() {
+ delete NodeList._instances[this[UID]];
+ },
+
+ refresh: function() {
+ var doc,
+ diff,
+ oldList = g_nodelists[this[UID]];
+ if (this._query) {
+ if (g_nodelists[this[UID]] &&
+ g_nodelists[this[UID]][0] &&
+ g_nodelists[this[UID]][0].ownerDocument) {
+ doc = g_nodelists[this[UID]][0].ownerDocument;
+ }
+
+ g_nodelists[this[UID]] = Y.Selector.query(this._query, doc || Y.config.doc);
+ diff = Y.Array.diff(oldList, g_nodelists[this[UID]]);
+ diff.added = diff.added ? Y.all(diff.added) : null;
+ diff.removed = diff.removed ? Y.all(diff.removed) : null;
+ this.fire('refresh', diff);
+ }
+ return this;
+ },
+
+ /**
+ * Applies an event listens to each Node bound to the NodeList.
+ * @method on
+ * @param {String} type The event being listened for
+ * @param {Function} fn The handler to call when the event fires
+ * @param {Object} context The context to call the handler with.
+ * Default is the NodeList instance.
+ * @return {Object} Returns an event handle that can later be use to detach().
+ * @see Event.on
+ */
+ on: function(type, fn, context) {
+ context = context || this;
+ this.batch(function(node) {
+ node.on.call(node, type, fn, context);
+ });
+ },
+
+ /**
+ * Applies an event listens to each Node bound to the NodeList.
+ * The handler is called only after all on() handlers are called
+ * and the event is not prevented.
+ * @method after
+ * @param {String} type The event being listened for
+ * @param {Function} fn The handler to call when the event fires
+ * @param {Object} context The context to call the handler with.
+ * Default is the NodeList instance.
+ * @return {Object} Returns an event handle that can later be use to detach().
+ * @see Event.on
+ */
+ after: function(type, fn, context) {
+ context = context || this;
+ this.batch(function(node) {
+ node.after.call(node, type, fn, context);
+ });
+ },
+
+ /**
+ * Returns the current number of items in the NodeList.
+ * @method size
+ * @return {Int} The number of items in the NodeList.
+ */
+ size: function() {
+ return g_nodelists[this[UID]].length;
+ },
+
+ /** Called on each Node instance
+ * @get
+ * @see Node
+ */
+ // one-off because we cant import from Node due to undefined return values
+ get: function(name) {
+ var ret = [],
+ tmp = NodeList._getTempNode();
+
+ NodeList.each(this, function(node) {
+ var instance = Y.Node._instances[node[UID]];
+ if (!instance) {
+ g_nodes[tmp[UID]] = node;
+ instance = tmp;
+ }
+ ret[ret.length] = instance.get(name);
+ });
+
+ return ret;
+ },
+
+ toString: function() {
+ var str = '',
+ errorMsg = this[UID] + ': not bound to any nodes',
+ nodes = g_nodelists[this[UID]],
+ node;
+
+ if (nodes && nodes[0]) {
+ node = nodes[0];
+ str += node[NODE_NAME];
+ if (node.id) {
+ str += '#' + node.id;
+ }
+
+ if (node.className) {
+ str += '.' + node.className.replace(' ', '.');
+ }
+
+ if (nodes.length > 1) {
+ str += '...[' + nodes.length + ' items]';
+ }
+ }
+ return str || errorMsg;
+ }
+
+}, true);
+
+NodeList.importMethod(Y.Node.prototype, [
+ /**
+ * Called on each Node instance
+ * @for NodeList
+ * @method append
+ * @see Node.append
+ */
+ 'append',
+
+ /**
+ * Called on each Node instance
+ * @method detach
+ * @see Node.detach
+ */
+ 'detach',
+
+ /** Called on each Node instance
+ * @method detachAll
+ * @see Node.detachAll
+ */
+ 'detachAll',
+
+ /** Called on each Node instance
+ * @method insert
+ * @see NodeInsert
+ */
+ 'insert',
+
+ /** Called on each Node instance
+ * @method plug
+ * @see Node.plug
+ */
+ 'plug',
+
+ /** Called on each Node instance
+ * @method prepend
+ * @see Node.prepend
+ */
+ 'prepend',
+
+ /** Called on each Node instance
+ * @method remove
+ * @see Node.remove
+ */
+ 'remove',
+
+ /** Called on each Node instance
+ * @method set
+ * @see Node.set
+ */
+ 'set',
+
+ /** Called on each Node instance
+ * @method setContent
+ * @see Node.setContent
+ */
+ 'setContent',
+
+ /** Called on each Node instance
+ * @method unplug
+ * @see Node.unplug
+ */
+ 'unplug'
+]);
+
+Y.NodeList = NodeList;
+Y.all = function(nodes, doc, restrict) {
+ // TODO: propagate restricted to nodes?
+ var nodeList = new NodeList({
+ nodes: nodes,
+ doc: doc,
+ restricted: restrict
+ });
+
+ // zero-length result returns null
+ return nodeList;
+};
+Y.Node.all = Y.all; // TODO: deprecated
+Y.Array.each([
+ /**
+ * Passes through to DOM method.
+ * @method replaceChild
+ * @for Node
+ * @param {HTMLElement | Node} node Node to be inserted
+ * @param {HTMLElement | Node} refNode Node to be replaced
+ * @return {Node} The replaced node
+ */
+ 'replaceChild',
+
+ /**
+ * Passes through to DOM method.
+ * @method appendChild
+ * @param {HTMLElement | Node} node Node to be appended
+ * @return {Node} The appended node
+ */
+ 'appendChild',
+
+ /**
+ * Passes through to DOM method.
+ * @method insertBefore
+ * @param {HTMLElement | Node} newNode Node to be appended
+ * @param {HTMLElement | Node} refNode Node to be inserted before
+ * @return {Node} The inserted node
+ */
+ 'insertBefore',
+
+ /**
+ * Passes through to DOM method.
+ * @method removeChild
+ * @param {HTMLElement | Node} node Node to be removed
+ * @return {Node} The removed node
+ */
+ 'removeChild',
+
+ /**
+ * Passes through to DOM method.
+ * @method hasChildNodes
+ * @return {Boolean} Whether or not the node has any childNodes
+ */
+ 'hasChildNodes',
+
+ /**
+ * Passes through to DOM method.
+ * @method cloneNode
+ * @param {HTMLElement | Node} node Node to be cloned
+ * @return {Node} The clone
+ */
+ 'cloneNode',
+
+ /**
+ * Passes through to DOM method.
+ * @method hasAttribute
+ * @param {String} attribute The attribute to test for
+ * @return {Boolean} Whether or not the attribute is present
+ */
+ 'hasAttribute',
+
+ /**
+ * Passes through to DOM method.
+ * @method removeAttribute
+ * @param {String} attribute The attribute to be removed
+ * @chainable
+ */
+ 'removeAttribute',
+
+ /**
+ * Passes through to DOM method.
+ * @method scrollIntoView
+ * @chainable
+ */
+ 'scrollIntoView',
+
+ /**
+ * Passes through to DOM method.
+ * @method getElementsByTagName
+ * @param {String} tagName The tagName to collect
+ * @return {NodeList} A NodeList representing the HTMLCollection
+ */
+ 'getElementsByTagName',
+
+ /**
+ * Passes through to DOM method.
+ * @method focus
+ * @chainable
+ */
+ 'focus',
+
+ /**
+ * Passes through to DOM method.
+ * @method blur
+ * @chainable
+ */
+ 'blur',
+
+ /**
+ * Passes through to DOM method.
+ * Only valid on FORM elements
+ * @method submit
+ * @chainable
+ */
+ 'submit',
+
+ /**
+ * Passes through to DOM method.
+ * Only valid on FORM elements
+ * @method reset
+ * @chainable
+ */
+ 'reset',
+
+ /**
+ * Passes through to DOM method.
+ * @method select
+ * @chainable
+ */
+ 'select'
+], function(method) {
+ Y.Node.prototype[method] = function(arg1, arg2, arg3) {
+ var ret = this.invoke(method, arg1, arg2, arg3);
+ return ret;
+ };
+});
+
+Node.importMethod(Y.DOM, [
+ /**
+ * Determines whether the ndoe is an ancestor of another HTML element in the DOM hierarchy.
+ * @method contains
+ * @param {Node | HTMLElement} needle The possible node or descendent
+ * @return {Boolean} Whether or not this node is the needle its ancestor
+ */
+ 'contains',
+ /**
+ * Allows setting attributes on DOM nodes, normalizing in some cases.
+ * This passes through to the DOM node, allowing for custom attributes.
+ * @method setAttribute
+ * @for Node
+ * @for NodeList
+ * @chainable
+ * @param {string} name The attribute name
+ * @param {string} value The value to set
+ */
+ 'setAttribute',
+ /**
+ * Allows getting attributes on DOM nodes, normalizing in some cases.
+ * This passes through to the DOM node, allowing for custom attributes.
+ * @method getAttribute
+ * @for Node
+ * @for NodeList
+ * @param {string} name The attribute name
+ * @return {string} The attribute value
+ */
+ 'getAttribute'
+]);
+
+if (!document.documentElement.hasAttribute) { // IE < 8
+ Y.Node.prototype.hasAttribute = function(attr) {
+ return Y.DOM.getAttribute(Y.Node.getDOMNode(this), attr) !== '';
+ };
+}
+
+/**
+ * Allows setting attributes on DOM nodes, normalizing in some cases.
+ * This passes through to the DOM node, allowing for custom attributes.
+ * @method setAttribute
+ * @see Node
+ * @for NodeList
+ * @chainable
+ * @param {string} name The attribute name
+ * @param {string} value The value to set
+ */
+
+/**
+ * Allows getting attributes on DOM nodes, normalizing in some cases.
+ * This passes through to the DOM node, allowing for custom attributes.
+ * @method getAttribute
+ * @see Node
+ * @for NodeList
+ * @param {string} name The attribute name
+ * @return {string} The attribute value
+ */
+Y.NodeList.importMethod(Y.Node.prototype, ['getAttribute', 'setAttribute']);
+
+(function() { // IE clones expandos; regenerate UID
+ var node = document.createElement('div'),
+ UID = '_yuid';
+
+ Y.stamp(node);
+ if (node[UID] === node.cloneNode(true)[UID]) {
+ Y.Node.prototype.cloneNode = function(deep) {
+ var node = Y.Node.getDOMNode(this).cloneNode(deep);
+ node[UID] = Y.guid();
+ return Y.get(node);
+ };
+ }
+})();
+(function(Y) {
+ var methods = [
+ /**
+ * Determines whether each node has the given className.
+ * @method hasClass
+ * @for Node
+ * @param {String} className the class name to search for
+ * @return {Array} An array of booleans for each node bound to the NodeList.
+ */
+ 'hasClass',
+
+ /**
+ * Adds a class name to each node.
+ * @method addClass
+ * @param {String} className the class name to add to the node's class attribute
+ * @chainable
+ */
+ 'addClass',
+
+ /**
+ * Removes a class name from each node.
+ * @method removeClass
+ * @param {String} className the class name to remove from the node's class attribute
+ * @chainable
+ */
+ 'removeClass',
+
+ /**
+ * Replace a class with another class for each node.
+ * If no oldClassName is present, the newClassName is simply added.
+ * @method replaceClass
+ * @param {String} oldClassName the class name to be replaced
+ * @param {String} newClassName the class name that will be replacing the old class name
+ * @chainable
+ */
+ 'replaceClass',
+
+ /**
+ * If the className exists on the node it is removed, if it doesn't exist it is added.
+ * @method toggleClass
+ * @param {String} className the class name to be toggled
+ * @chainable
+ */
+ 'toggleClass'
+ ];
+
+ Y.Node.importMethod(Y.DOM, methods);
+ /**
+ * Determines whether each node has the given className.
+ * @method hasClass
+ * @see Node.hasClass
+ * @for NodeList
+ * @param {String} className the class name to search for
+ * @return {Array} An array of booleans for each node bound to the NodeList.
+ */
+
+ /**
+ * Adds a class name to each node.
+ * @method addClass
+ * @see Node.addClass
+ * @param {String} className the class name to add to the node's class attribute
+ * @chainable
+ */
+
+ /**
+ * Removes a class name from each node.
+ * @method removeClass
+ * @see Node.removeClass
+ * @param {String} className the class name to remove from the node's class attribute
+ * @chainable
+ */
+
+ /**
+ * Replace a class with another class for each node.
+ * If no oldClassName is present, the newClassName is simply added.
+ * @method replaceClass
+ * @see Node.replaceClass
+ * @param {String} oldClassName the class name to be replaced
+ * @param {String} newClassName the class name that will be replacing the old class name
+ * @chainable
+ */
+
+ /**
+ * If the className exists on the node it is removed, if it doesn't exist it is added.
+ * @method toggleClass
+ * @see Node.toggleClass
+ * @param {String} className the class name to be toggled
+ * @chainable
+ */
+ Y.NodeList.importMethod(Y.Node.prototype, methods);
+})(Y);
+/**
+ * Functionality to make the node a delegated event container
+ * @module node
+ * @submodule node-event-delegate
+ */
+
+/**
+ * Functionality to make the node a delegated event container
+ * @method delegate
+ * @param type {String} the event type to delegate
+ * @param fn {Function} the function to execute
+ * @param selector {String} a selector that must match the target of the event.
+ * @return {Event.Handle} the detach handle
+ * @for Node
+ */
+Y.Node.prototype.delegate = function(type, fn, selector, context) {
+ context = context || this;
+ var args = Array.prototype.slice.call(arguments, 4),
+ a = ['delegate', fn, Y.Node.getDOMNode(this), type, selector, context];
+ a = a.concat(args);
+ return Y.on.apply(Y, a);
+};
+
+
+
+}, '3.0.0b1' ,{requires:['dom-base', 'base', 'selector']});
+YUI.add('node-style', function(Y) {
+
+(function(Y) {
+/**
+ * Extended Node interface for managing node styles.
+ * @module node
+ * @submodule node-style
+ */
+
+var methods = [
+ /**
+ * Returns the style's current value.
+ * @method getStyle
+ * @for Node
+ * @param {String} attr The style attribute to retrieve.
+ * @return {String} The current value of the style property for the element.
+ */
+ 'getStyle',
+
+ /**
+ * Returns the computed value for the given style property.
+ * @method getComputedStyle
+ * @param {String} attr The style attribute to retrieve.
+ * @return {String} The computed value of the style property for the element.
+ */
+ 'getComputedStyle',
+
+ /**
+ * Sets a style property of the node.
+ * @method setStyle
+ * @param {String} attr The style attribute to set.
+ * @param {String|Number} val The value.
+ * @chainable
+ */
+ 'setStyle',
+
+ /**
+ * Sets multiple style properties on the node.
+ * @method setStyles
+ * @param {Object} hash An object literal of property:value pairs.
+ * @chainable
+ */
+ 'setStyles'
+];
+Y.Node.importMethod(Y.DOM, methods);
+/**
+ * Returns an array of values for each node.
+ * @method getStyle
+ * @for NodeList
+ * @see Node.getStyle
+ * @param {String} attr The style attribute to retrieve.
+ * @return {Array} The current values of the style property for the element.
+ */
+
+/**
+ * Returns an array of the computed value for each node.
+ * @method getComputedStyle
+ * @see Node.getComputedStyle
+ * @param {String} attr The style attribute to retrieve.
+ * @return {Array} The computed values for each node.
+ */
+'getComputedStyle',
+
+/**
+ * Sets a style property on each node.
+ * @method setStyle
+ * @see Node.setStyle
+ * @param {String} attr The style attribute to set.
+ * @param {String|Number} val The value.
+ * @chainable
+ */
+'setStyle',
+
+/**
+ * Sets multiple style properties on each node.
+ * @method setStyles
+ * @see Node.setStyles
+ * @param {Object} hash An object literal of property:value pairs.
+ * @chainable
+ */
+'setStyles'
+Y.NodeList.importMethod(Y.Node.prototype, methods);
+})(Y);
+
+
+}, '3.0.0b1' ,{requires:['dom-style', 'node-base']});
+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 winHeight
+ * @type {Int}
+ */
+ 'docWidth',
+
+ /**
+ * Document height
+ * @config docHeight
+ * @type {Int}
+ */
+ 'docHeight',
+
+ /**
+ * Amount page has been scroll vertically
+ * @config docScrollX
+ * @type {Int}
+ */
+ 'docScrollX',
+
+ /**
+ * Amount page has been scroll horizontally
+ * @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'
+]);
+
+/**
+ * Returns a region object for the node
+ * @config region
+ * @for Node
+ * @type Node
+ */
+Y.Node.ATTRS.region = {
+ getter: function() {
+ var node = Y.Node.getDOMNode(this);
+ if (node && !node.tagName) {
+ if (node.nodeType === 9) { // document
+ node = node.documentElement;
+ } else if (node.alert) { // window
+ node = node.document.documentElement;
+ }
+ }
+ return Y.DOM.region(node);
+ }
+};
+
+/**
+ * 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 (node2 instanceof 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 (node2 instanceof Y.Node) { // might be a region object
+ node2 = Y.Node.getDOMNode(node2);
+ }
+ return Y.DOM.inRegion(node1, node2, all, altRegion);
+};
+
+
+}, '3.0.0b1' ,{requires:['dom-screen']});
+YUI.add('node-aria', function(Y) {
+
+/**
+ * Aria support for Node
+ * @module node
+ * @submodule node-aria
+ */
+
+Y.Node.re_aria = /^(?:role$|aria-)/;
+
+Y.Node.prototype._addAriaAttr = function(name) {
+ this.addAttr(name, {
+ getter: function() {
+ return Y.Node.getDOMNode(this).getAttribute(name, 2);
+ },
+
+ setter: function(val) {
+ Y.Node.getDOMNode(this).setAttribute(name, val);
+ return val;
+ }
+ });
+};
+
+
+}, '3.0.0b1' ,{requires:['node-base']});
+
+
+YUI.add('node', function(Y){}, '3.0.0b1' ,{skinnable:false, use:['node-base', 'node-style', 'node-screen', 'node-aria']});
+