comt: comparison src/cm/media/js/lib/yui/yui_3.0.0b1/build/dom/dom-debug.js

Mercurial Mercurial > comt / comparison

summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help

src/cm/media/js/lib/yui/yui_3.0.0b1/build/dom/dom-debug.js

changeset 0

40c8f766c9b8

equal deleted inserted replaced

--1:000000000000
+:40c8f766c9b8
+/*
+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('dom-base', function(Y) {
+(function(Y) {
+/**
+* The DOM utility provides a cross-browser abtraction layer
+* normalizing DOM tasks, and adds extra helper functionality
+* for other common tasks.
+* @module dom
+* @submodule dom-base
+*
+*/
+/**
+* Provides DOM helper methods.
+* @class DOM
+*
+*/
+var NODE_TYPE = 'nodeType',
+OWNER_DOCUMENT = 'ownerDocument',
+DOCUMENT_ELEMENT = 'documentElement',
+DEFAULT_VIEW = 'defaultView',
+PARENT_WINDOW = 'parentWindow',
+TAG_NAME = 'tagName',
+PARENT_NODE = 'parentNode',
+FIRST_CHILD = 'firstChild',
+LAST_CHILD = 'lastChild',
+PREVIOUS_SIBLING = 'previousSibling',
+NEXT_SIBLING = 'nextSibling',
+CONTAINS = 'contains',
+COMPARE_DOCUMENT_POSITION = 'compareDocumentPosition',
+re_tag = /<([a-z]+)/i;
+Y.DOM = {
+/**
+* Returns the HTMLElement with the given ID (Wrapper for document.getElementById).
+* @method byId
+* @param {String} id the id attribute
+* @param {Object} doc optional The document to search. Defaults to current document
+* @return {HTMLElement | null} The HTMLElement with the id, or null if none found.
+*/
+byId: function(id, doc) {
+doc = doc || Y.config.doc;
+// TODO: IE Name
+return doc.getElementById(id);
+},
+/**
+* Returns the text content of the HTMLElement.
+* @method getText
+* @param {HTMLElement} element The html element.
+* @return {String} The text content of the element (includes text of any descending elements).
+*/
+getText: (document.documentElement.textContent !== undefined) ?
+function(element) {
+var ret = '';
+if (element) {
+ret = element.textContent;
+}
+return ret || '';
+} : function(element) {
+var ret = '';
+if (element) {
+ret = element.innerText;
+}
+return ret || '';
+},
+/**
+* Sets the text content of the HTMLElement.
+* @method setText
+* @param {HTMLElement} element The html element.
+* @param {String} content The content to add.
+*/
+setText: (document.documentElement.textContent !== undefined) ?
+function(element, content) {
+if (element) {
+element.textContent = content;
+}
+} : function(element, content) {
+if (element) {
+element.innerText = content;
+}
+},
+// TODO: pull out sugar (rely on _childBy, byAxis, etc)?
+/*
+* Finds the firstChild of the given HTMLElement.
+* @method firstChild
+* @deprecated Use _childBy
+* @param {HTMLElement} element The html element.
+* @param {Function} fn optional An optional boolean test to apply.
+* The optional function is passed the current HTMLElement being tested as its only argument.
+* If no function is given, the first found is returned.
+* @return {HTMLElement | null} The first matching child html element.
+*/
+firstChild: function(element, fn) {
+return Y.DOM._childBy(element, null, fn);
+},
+// @deprecated Use _childBy
+firstChildByTag: function(element, tag, fn) {
+return Y.DOM._childBy(element, tag, fn);
+},
+/*
+* Finds the lastChild of the given HTMLElement.
+* @method lastChild
+* @deprecated Use _childBy
+* @param {HTMLElement} element The html element.
+* @param {String} tag The tag to search for.
+* @param {Function} fn optional An optional boolean test to apply.
+* The optional function is passed the current HTMLElement being tested as its only argument.
+* If no function is given, the first found is returned.
+* @return {HTMLElement | null} The first matching child html element.
+*/
+lastChild: function(element, fn) {
+return Y.DOM._childBy(element, null, fn, true);
+},
+// @deprecated Use _childBy
+lastChildByTag: function(element, tag, fn) {
+return Y.DOM._childBy(element, tag, fn, true);
+},
+/*
+* Finds all HTMLElement childNodes matching the given tag.
+* @method childrenByTag
+* @deprecated Use Selector
+* @param {HTMLElement} element The html element.
+* @param {String} tag The tag to search for.
+* @param {Function} fn optional An optional boolean test to apply.
+* The optional function is passed the current HTMLElement being tested as its only argument.
+* If no function is given, all children with the given tag are collected.
+* @return {Array} The collection of child elements.
+* TODO: Webkit children.tags() returns grandchildren
+*/
+_childrenByTag: function() {
+if (document[DOCUMENT_ELEMENT].children) {
+return function(element, tag, fn, toArray) { // TODO: keep toArray option?
+tag = (tag && tag !== '*') ? tag.toUpperCase() : null;
+var elements = [],
+wrapFn = fn;
+if (element) {
+if (tag && !Y.UA.webkit) { // children.tags() broken in safari
+elements = element.children.tags(tag);
+} else {
+elements = element.children;
+if (tag) {
+wrapFn = function(el) {
+return el[TAG_NAME].toUpperCase() === tag && (!fn || fn(el));
+};
+}
+}
+elements = Y.DOM.filterElementsBy(elements, wrapFn);
+}
+return elements;
+};
+} else {
+return function(element, tag, fn) {
+tag = (tag && tag !== '*') ? tag.toUpperCase() : null;
+var elements = [],
+wrapFn = fn;
+if (element) {
+elements = element.childNodes;
+if (tag) { // wrap fn and add tag test TODO: allow tag in filterElementsBy?
+wrapFn = function(el) {
+return el[TAG_NAME].toUpperCase() === tag && (!fn || fn(el));
+};
+}
+elements = Y.DOM.filterElementsBy(elements, wrapFn);
+}
+return elements;
+};
+}
+}(),
+/*
+* Finds all HTMLElement childNodes.
+* @method children
+* @deprecated Use Selector
+* @param {HTMLElement} element The html element.
+* @param {Function} fn optional An optional boolean test to apply.
+* The optional function is passed the current HTMLElement being tested as its only argument.
+* If no function is given, all children are collected.
+* @return {Array} The collection of child elements.
+*/
+children: function(element, fn) {
+return Y.DOM._childrenByTag(element, null, fn);
+},
+/*
+* Finds the previous sibling of the element.
+* @method previous
+* @deprecated Use elementByAxis
+* @param {HTMLElement} element The html element.
+* @param {Function} fn optional An optional boolean test to apply.
+* The optional function is passed the current DOM node being tested as its only argument.
+* If no function is given, the first sibling is returned.
+* @param {Boolean} all optional Whether all node types should be scanned, or just element nodes.
+* @return {HTMLElement | null} The matching DOM node or null if none found.
+*/
+previous: function(element, fn, all) {
+return Y.DOM.elementByAxis(element, PREVIOUS_SIBLING, fn, all);
+},
+/*
+* Finds the next sibling of the element.
+* @method next
+* @deprecated Use elementByAxis
+* @param {HTMLElement} element The html element.
+* @param {Function} fn optional An optional boolean test to apply.
+* The optional function is passed the current DOM node being tested as its only argument.
+* If no function is given, the first sibling is returned.
+* @param {Boolean} all optional Whether all node types should be scanned, or just element nodes.
+* @return {HTMLElement | null} The matching DOM node or null if none found.
+*/
+next: function(element, fn, all) {
+return Y.DOM.elementByAxis(element, NEXT_SIBLING, fn, all);
+},
+/*
+* Finds the ancestor of the element.
+* @method ancestor
+* @deprecated Use elementByAxis
+* @param {HTMLElement} element The html element.
+* @param {Function} fn optional An optional boolean test to apply.
+* The optional function is passed the current DOM node being tested as its only argument.
+* If no function is given, the parentNode is returned.
+* @param {Boolean} all optional Whether all node types should be scanned, or just element nodes.
+* @return {HTMLElement | null} The matching DOM node or null if none found.
+*/
+// TODO: optional stopAt node?
+ancestor: function(element, fn, all) {
+return Y.DOM.elementByAxis(element, PARENT_NODE, fn, all);
+},
+/**
+* Searches the element by the given axis for the first matching element.
+* @method elementByAxis
+* @param {HTMLElement} element The html element.
+* @param {String} axis The axis to search (parentNode, nextSibling, previousSibling).
+* @param {Function} fn optional An optional boolean test to apply.
+* @param {Boolean} all optional Whether all node types should be returned, or just element nodes.
+* The optional function is passed the current HTMLElement being tested as its only argument.
+* If no function is given, the first element is returned.
+* @return {HTMLElement | null} The matching element or null if none found.
+*/
+elementByAxis: function(element, axis, fn, all) {
+while (element && (element = element[axis])) { // NOTE: assignment
+if ( (all || element[TAG_NAME]) && (!fn || fn(element)) ) {
+return element;
+}
+}
+return null;
+},
+/*
+* Finds all elements with the given tag.
+* @method byTag
+* @deprecated Use Selector
+* @param {String} tag The tag being search for.
+* @param {HTMLElement} root optional An optional root element to start from.
+* @param {Function} fn optional An optional boolean test to apply.
+* The optional function is passed the current HTMLElement being tested as its only argument.
+* If no function is given, all elements with the given tag are returned.
+* @return {Array} The collection of matching elements.
+*/
+byTag: function(tag, root, fn) {
+root = root || Y.config.doc;
+var elements = root.getElementsByTagName(tag),
+retNodes = [],
+i, len;
+for (i = 0, len = elements.length; i < len; ++i) {
+if ( !fn || fn(elements[i]) ) {
+retNodes[retNodes.length] = elements[i];
+}
+}
+return retNodes;
+},
+/*
+* Finds the first element with the given tag.
+* @method firstByTag
+* @deprecated Use Selector
+* @param {String} tag The tag being search for.
+* @param {HTMLElement} root optional An optional root element to start from.
+* @param {Function} fn optional An optional boolean test to apply.
+* The optional function is passed the current HTMLElement being tested as its only argument.
+* If no function is given, the first match is returned.
+* @return {HTMLElement} The matching element.
+*/
+firstByTag: function(tag, root, fn) {
+root = root || Y.config.doc;
+var elements = root.getElementsByTagName(tag),
+ret = null,
+i, len;
+for (i = 0, len = elements.length; i < len; ++i) {
+if ( !fn || fn(elements[i]) ) {
+ret = elements[i];
+break;
+}
+}
+return ret;
+},
+/*
+* Filters a collection of HTMLElements by the given attributes.
+* @method filterElementsBy
+* @param {Array} elements The collection of HTMLElements to filter.
+* @param {Function} fn A boolean test to apply.
+* The function is passed the current HTMLElement being tested as its only argument.
+* If no function is given, all HTMLElements are kept.
+* @return {Array} The filtered collection of HTMLElements.
+*/
+filterElementsBy: function(elements, fn, firstOnly) {
+var ret = (firstOnly) ? null : [],
+i, len;
+for (i = 0, len = elements.length; i < len; ++i) {
+if (elements[i][TAG_NAME] && (!fn || fn(elements[i]))) {
+if (firstOnly) {
+ret = elements[i];
+break;
+} else {
+ret[ret.length] = elements[i];
+}
+}
+}
+return ret;
+},
+/**
+* Determines whether or not one HTMLElement is or contains another HTMLElement.
+* @method contains
+* @param {HTMLElement} element The containing html element.
+* @param {HTMLElement} needle The html element that may be contained.
+* @return {Boolean} Whether or not the element is or contains the needle.
+*/
+contains: function(element, needle) {
+var ret = false;
+if ( !needle || !element || !needle[NODE_TYPE] || !element[NODE_TYPE]) {
+ret = false;
+} else if (element[CONTAINS])  {
+if (Y.UA.opera || needle[NODE_TYPE] === 1) { // IE & SAF contains fail if needle not an ELEMENT_NODE
+ret = element[CONTAINS](needle);
+} else {
+ret = Y.DOM._bruteContains(element, needle);
+}
+} else if (element[COMPARE_DOCUMENT_POSITION]) { // gecko
+if (element === needle || !!(element[COMPARE_DOCUMENT_POSITION](needle) & 16)) {
+ret = true;
+}
+}
+return ret;
+},
+/**
+* Determines whether or not the HTMLElement is part of the document.
+* @method inDoc
+* @param {HTMLElement} element The containing html element.
+* @param {HTMLElement} doc optional The document to check.
+* @return {Boolean} Whether or not the element is attached to the document.
+*/
+inDoc: function(element, doc) {
+doc = doc || element[OWNER_DOCUMENT];
+var id = element.id;
+if (!id) { // TODO: remove when done?
+id = element.id = Y.guid();
+}
+return !! (doc.getElementById(id));
+},
+/**
+* Inserts the new node as the previous sibling of the reference node
+* @method insertBefore
+* @param {String | HTMLElement} newNode The node to be inserted
+* @param {String | HTMLElement} referenceNode The node to insert the new node before
+* @return {HTMLElement} The node that was inserted (or null if insert fails)
+*/
+insertBefore: function(newNode, referenceNode) {
+var ret = null,
+parent;
+if (newNode && referenceNode && (parent = referenceNode.parentNode)) { // NOTE: assignment
+if (typeof newNode === 'string') {
+newNode = Y.DOM.create(newNode);
+}
+ret = parent.insertBefore(newNode, referenceNode);
+} else {
+Y.log('insertBefore failed: missing or invalid arg(s)', 'error', 'dom');
+}
+return ret;
+},
+/**
+* Inserts the new node as the next sibling of the reference node
+* @method insertAfter
+* @param {String | HTMLElement} newNode The node to be inserted
+* @param {String | HTMLElement} referenceNode The node to insert the new node after
+* @return {HTMLElement} The node that was inserted (or null if insert fails)
+*/
+insertAfter: function(newNode, referenceNode) {
+if (!newNode || !referenceNode || !referenceNode[PARENT_NODE]) {
+Y.log('insertAfter failed: missing or invalid arg(s)', 'error', 'DOM');
+return null;
+}
+if (typeof newNode === 'string') {
+newNode = Y.DOM.create(newNode);
+}
+if (referenceNode[NEXT_SIBLING]) {
+return referenceNode[PARENT_NODE].insertBefore(newNode, referenceNode[NEXT_SIBLING]);
+} else {
+return referenceNode[PARENT_NODE].appendChild(newNode);
+}
+},
+/**
+* Creates a new dom 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: function(html, doc) {
+html = Y.Lang.trim(html); // match IE which trims whitespace from innerHTML
+if (!doc && Y.DOM._cloneCache[html]) {
+return Y.DOM._cloneCache[html].cloneNode(true); // NOTE: return
+}
+doc = doc || Y.config.doc;
+var m = re_tag.exec(html),
+create = Y.DOM._create,
+custom = Y.DOM.creators,
+ret = null,
+tag, nodes;
+if (m && custom[m[1]]) {
+if (typeof custom[m[1]] === 'function') {
+create = custom[m[1]];
+} else {
+tag = custom[m[1]];
+}
+}
+nodes = create(html, doc, tag).childNodes;
+if (nodes.length === 1) { // return single node, breaking parentNode ref from "fragment"
+ret = nodes[0].parentNode.removeChild(nodes[0]);
+} else { // return multiple nodes as a fragment
+ret = doc.createDocumentFragment();
+while (nodes.length) {
+ret.appendChild(nodes[0]);
+}
+}
+Y.DOM._cloneCache[html] = ret.cloneNode(true);
+return ret;
+},
+CUSTOM_ATTRIBUTES: (!document.documentElement.hasAttribute) ? { // IE < 8
+'for': 'htmlFor',
+'class': 'className'
+} : { // w3c
+'htmlFor': 'for',
+'className': 'class'
+},
+/**
+* Provides a normalized attribute interface.
+* @method setAttibute
+* @param {String | HTMLElement} el The target element for the attribute.
+* @param {String} attr The attribute to set.
+* @param {String} val The value of the attribute.
+*/
+setAttribute: function(el, attr, val) {
+if (el && el.setAttribute) {
+attr = Y.DOM.CUSTOM_ATTRIBUTES[attr] || attr;
+el.setAttribute(attr, val);
+}
+},
+/**
+* Provides a normalized attribute interface.
+* @method getAttibute
+* @param {String | HTMLElement} el The target element for the attribute.
+* @param {String} attr The attribute to get.
+* @return {String} The current value of the attribute.
+*/
+getAttribute: function(el, attr) {
+var ret = '';
+if (el && el.getAttribute) {
+attr = Y.DOM.CUSTOM_ATTRIBUTES[attr] || attr;
+ret = el.getAttribute(attr, 2);
+if (ret === null) {
+ret = ''; // per DOM spec
+}
+}
+return ret;
+},
+// @deprecated
+srcIndex: (document.documentElement.sourceIndex) ?
+function(node) {
+return (node && node.sourceIndex) ? node.sourceIndex : null;
+} :
+function(node) {
+return (node && node[OWNER_DOCUMENT]) ?
+[].indexOf.call(node[OWNER_DOCUMENT].
+getElementsByTagName('*'), node) : null;
+},
+isWindow: function(obj) {
+return obj.alert && obj.document;
+},
+_fragClones: {
+div: document.createElement('div')
+},
+_create: function(html, doc, tag) {
+tag = tag || 'div';
+var frag = Y.DOM._fragClones[tag];
+if (frag) {
+frag = frag.cloneNode(false);
+} else {
+frag = Y.DOM._fragClones[tag] = doc.createElement(tag);
+}
+frag.innerHTML = html;
+return frag;
+},
+_removeChildNodes: function(node) {
+while (node.firstChild) {
+node.removeChild(node.firstChild);
+}
+},
+_cloneCache: {},
+/**
+* Inserts content in a node at the given location
+* @method addHTML
+* @param {HTMLElement} node The node to insert into
+* @param {String} content The content to be inserted
+* @param {String} where Where to insert the content; default is after lastChild
+*/
+addHTML: function(node, content, where) {
+if (typeof content === 'string') {
+content = Y.Lang.trim(content); // match IE which trims whitespace from innerHTML
+}
+var newNode = Y.DOM._cloneCache[content];
+if (newNode) {
+newNode = newNode.cloneNode(true);
+} else {
+if (content.nodeType) { // domNode
+newNode = content;
+} else { // create from string and cache
+newNode = Y.DOM.create(content);
+}
+}
+if (where) {
+if (where.nodeType) { // insert regardless of relationship to node
+// TODO: check if node.contains(where)?
+where.parentNode.insertBefore(newNode, where);
+} else {
+switch (where) {
+case 'replace':
+while (node.firstChild) {
+node.removeChild(node.firstChild);
+}
+node.appendChild(newNode);
+break;
+case 'before':
+node.parentNode.insertBefore(newNode, node);
+break;
+case 'after':
+if (node.nextSibling) { // IE errors if refNode is null
+node.parentNode.insertBefore(newNode, node.nextSibling);
+} else {
+node.parentNode.appendChild(newNode);
+}
+break;
+default:
+node.appendChild(newNode);
+}
+}
+} else {
+node.appendChild(newNode);
+}
+return newNode;
+},
+VALUE_SETTERS: {},
+VALUE_GETTERS: {},
+getValue: function(node) {
+var ret = '', // TODO: return null?
+getter;
+if (node && node[TAG_NAME]) {
+getter = Y.DOM.VALUE_GETTERS[node[TAG_NAME].toLowerCase()];
+if (getter) {
+ret = getter(node);
+} else {
+ret = node.value;
+}
+}
+return (typeof ret === 'string') ? ret : '';
+},
+setValue: function(node, val) {
+var setter;
+if (node && node[TAG_NAME]) {
+setter = Y.DOM.VALUE_SETTERS[node[TAG_NAME].toLowerCase()];
+if (setter) {
+setter(node, val);
+} else {
+node.value = val;
+}
+}
+},
+_stripScripts: function(node) {
+var scripts = node.getElementsByTagName('script'),
+i, script;
+for (i = 0, script; script = scripts[i++];) {
+script.parentNode.removeChild(script);
+}
+},
+_execScripts: function(scripts, startIndex) {
+var newScript,
+i, script;
+startIndex = startIndex || 0;
+for (i = startIndex, script; script = scripts[i++];) {
+newScript = script.ownerDocument.createElement('script');
+script.parentNode.replaceChild(newScript, script);
+if (script.text) {
+newScript.text = script.text;
+} else if (script.src) {
+newScript.src = script.src;
+// "pause" while loading to ensure exec order
+// FF reports typeof onload as "undefined", so try IE first
+if (typeof newScript.onreadystatechange !== 'undefined') {
+newScript.onreadystatechange = function() {
+if (/loaded|complete/.test(script.readyState)) {
+event.srcElement.onreadystatechange = null;
+// timer to help ensure exec order
+setTimeout(function() {
+Y.DOM._execScripts(scripts, i++);
+}, 0);
+}
+};
+} else {
+newScript.onload = function(e) {
+e.target.onload = null;
+Y.DOM._execScripts(scripts, i++);
+};
+}
+return; // NOTE: early return to chain async loading
+}
+}
+},
+/**
+* Brute force version of contains.
+* Used for browsers without contains support for non-HTMLElement Nodes (textNodes, etc).
+* @method _bruteContains
+* @private
+* @param {HTMLElement} element The containing html element.
+* @param {HTMLElement} needle The html element that may be contained.
+* @return {Boolean} Whether or not the element is or contains the needle.
+*/
+_bruteContains: function(element, needle) {
+while (needle) {
+if (element === needle) {
+return true;
+}
+needle = needle.parentNode;
+}
+return false;
+},
+// TODO: move to Lang?
+/**
+* Memoizes dynamic regular expressions to boost runtime performance.
+* @method _getRegExp
+* @private
+* @param {String} str The string to convert to a regular expression.
+* @param {String} flags optional An optinal string of flags.
+* @return {RegExp} An instance of RegExp
+*/
+_getRegExp: function(str, flags) {
+flags = flags || '';
+Y.DOM._regexCache = Y.DOM._regexCache || {};
+if (!Y.DOM._regexCache[str + flags]) {
+Y.DOM._regexCache[str + flags] = new RegExp(str, flags);
+}
+return Y.DOM._regexCache[str + flags];
+},
+// TODO: make getDoc/Win true privates?
+/**
+* returns the appropriate document.
+* @method _getDoc
+* @private
+* @param {HTMLElement} element optional Target element.
+* @return {Object} The document for the given element or the default document.
+*/
+_getDoc: function(element) {
+element = element || {};
+return (element[NODE_TYPE] === 9) ? element : // element === document
+element[OWNER_DOCUMENT] || // element === DOM node
+element.document || // element === window
+Y.config.doc; // default
+},
+/**
+* returns the appropriate window.
+* @method _getWin
+* @private
+* @param {HTMLElement} element optional Target element.
+* @return {Object} The window for the given element or the default window.
+*/
+_getWin: function(element) {
+var doc = Y.DOM._getDoc(element);
+return doc[DEFAULT_VIEW] || doc[PARENT_WINDOW] || Y.config.win;
+},
+// @deprecated, use Selector
+_childBy: function(element, tag, fn, rev) {
+var ret = null,
+root, axis;
+if (element) {
+if (rev) {
+root = element[LAST_CHILD];
+axis = PREVIOUS_SIBLING;
+} else {
+root = element[FIRST_CHILD];
+axis = NEXT_SIBLING;
+}
+if (Y.DOM._testElement(root, tag, fn)) { // is the matching element
+ret = root;
+} else { // need to scan nextSibling axis of firstChild to find matching element
+ret = Y.DOM.elementByAxis(root, axis, fn);
+}
+}
+return ret;
+},
+_batch: function(nodes, fn, arg1, arg2, arg3, etc) {
+fn = (typeof name === 'string') ? Y.DOM[fn] : fn;
+var result,
+ret = [];
+if (fn && nodes) {
+Y.each(nodes, function(node) {
+if ((result = fn.call(Y.DOM, node, arg1, arg2, arg3, etc)) !== undefined) {
+ret[ret.length] = result;
+}
+});
+}
+return ret.length ? ret : nodes;
+},
+_testElement: function(element, tag, fn) {
+tag = (tag && tag !== '*') ? tag.toUpperCase() : null;
+return (element && element[TAG_NAME] &&
+(!tag || element[TAG_NAME].toUpperCase() === tag) &&
+(!fn || fn(element)));
+},
+creators: {},
+_IESimpleCreate: function(html, doc) {
+doc = doc || Y.config.doc;
+return doc.createElement(html);
+}
+};
+(function(Y) {
+var creators = Y.DOM.creators,
+create = Y.DOM.create,
+re_tbody = /(?:\/(?:thead|tfoot|tbody|caption|col|colgroup)>)+\s*<tbody/,
+TABLE_OPEN = '<table>',
+TABLE_CLOSE = '</table>';
+if (Y.UA.gecko || Y.UA.ie) { // require custom creation code for certain element types
+Y.mix(creators, {
+option: function(html, doc) {
+return create('<select>' + html + '</select>', doc);
+},
+tr: function(html, doc) {
+return create('<tbody>' + html + '</tbody>', doc);
+},
+td: function(html, doc) {
+return create('<tr>' + html + '</tr>', doc);
+},
+tbody: function(html, doc) {
+return create(TABLE_OPEN + html + TABLE_CLOSE, doc);
+},
+legend: 'fieldset'
+});
+creators.col = creators.tbody; // IE wraps in colgroup
+}
+if (Y.UA.ie) {
+Y.mix(creators, {
+// TODO: thead/tfoot with nested tbody
+// IE adds TBODY when creating TABLE elements (which may share this impl)
+tbody: function(html, doc) {
+var frag = create(TABLE_OPEN + html + TABLE_CLOSE, doc),
+tb = frag.children.tags('tbody')[0];
+if (frag.children.length > 1 && tb && !re_tbody.test(html)) {
+tb[PARENT_NODE].removeChild(tb); // strip extraneous tbody
+}
+return frag;
+},
+script: function(html, doc) {
+var frag = doc.createElement('div');
+frag.innerHTML = '-' + html;
+frag.removeChild(frag[FIRST_CHILD]);
+return frag;
+}
+}, true);
+Y.mix(Y.DOM.VALUE_GETTERS, {
+button: function(node) {
+return (node.attributes && node.attributes.value) ? node.attributes.value.value : '';
+}
+});
+Y.mix(Y.DOM.VALUE_SETTERS, {
+// IE: node.value changes the button text, which should be handled via innerHTML
+button: function(node, val) {
+var attr = node.attributes.value;
+if (!attr) {
+attr = node[OWNER_DOCUMENT].createAttribute('value');
+node.setAttributeNode(attr);
+}
+attr.value = val;
+}
+});
+}
+if (Y.UA.gecko || Y.UA.ie) {
+Y.mix(creators, {
+th: creators.td,
+thead: creators.tbody,
+tfoot: creators.tbody,
+caption: creators.tbody,
+colgroup: creators.tbody,
+col: creators.tbody,
+optgroup: creators.option
+});
+}
+Y.mix(Y.DOM.VALUE_GETTERS, {
+option: function(node) {
+var attrs = node.attributes;
+return (attrs.value && attrs.value.specified) ? node.value : node.text;
+},
+select: function(node) {
+var val = node.value,
+options = node.options;
+if (options && val === '') {
+if (node.multiple) {
+Y.log('multiple select normalization not implemented', 'warn', 'DOM');
+} else {
+val = Y.DOM.getValue(options[node.selectedIndex], 'value');
+}
+}
+return val;
+}
+});
+})(Y);
+})(Y);
+Y.mix(Y.DOM, {
+/**
+* Determines whether a DOM element has the given className.
+* @method hasClass
+* @param {HTMLElement} element The DOM element.
+* @param {String} className the class name to search for
+* @return {Boolean} Whether or not the element has the given class.
+*/
+hasClass: function(node, className) {
+var re = Y.DOM._getRegExp('(?:^|\\s+)' + className + '(?:\\s+|$)');
+return re.test(node.className);
+},
+/**
+* Adds a class name to a given DOM element.
+* @method addClass
+* @param {HTMLElement} element The DOM element.
+* @param {String} className the class name to add to the class attribute
+*/
+addClass: function(node, className) {
+if (!Y.DOM.hasClass(node, className)) { // skip if already present
+node.className = Y.Lang.trim([node.className, className].join(' '));
+}
+},
+/**
+* Removes a class name from a given element.
+* @method removeClass
+* @param {HTMLElement} element The DOM element.
+* @param {String} className the class name to remove from the class attribute
+*/
+removeClass: function(node, className) {
+if (className && Y.DOM.hasClass(node, className)) {
+node.className = Y.Lang.trim(node.className.replace(Y.DOM._getRegExp('(?:^|\\s+)' +
+className + '(?:\\s+|$)'), ' '));
+if ( Y.DOM.hasClass(node, className) ) { // in case of multiple adjacent
+Y.DOM.removeClass(node, className);
+}
+}
+},
+/**
+* Replace a class with another class for a given element.
+* If no oldClassName is present, the newClassName is simply added.
+* @method replaceClass
+* @param {HTMLElement} element The DOM element.
+* @param {String} oldClassName the class name to be replaced
+* @param {String} newClassName the class name that will be replacing the old class name
+*/
+replaceClass: function(node, oldC, newC) {
+//Y.log('replaceClass replacing ' + oldC + ' with ' + newC, 'info', 'Node');
+Y.DOM.addClass(node, newC);
+Y.DOM.removeClass(node, oldC);
+},
+/**
+* If the className exists on the node it is removed, if it doesn't exist it is added.
+* @method toggleClass
+* @param {HTMLElement} element The DOM element.
+* @param {String} className the class name to be toggled
+*/
+toggleClass: function(node, className) {
+if (Y.DOM.hasClass(node, className)) {
+Y.DOM.removeClass(node, className);
+} else {
+Y.DOM.addClass(node, className);
+}
+}
+});
+}, '3.0.0b1' ,{requires:['event'], skinnable:false});
+YUI.add('dom-style', function(Y) {
+(function(Y) {
+/**
+* Add style management functionality to DOM.
+* @module dom
+* @submodule dom-style
+* @for DOM
+*/
+var DOCUMENT_ELEMENT = 'documentElement',
+DEFAULT_VIEW = 'defaultView',
+OWNER_DOCUMENT = 'ownerDocument',
+STYLE = 'style',
+FLOAT = 'float',
+CSS_FLOAT = 'cssFloat',
+STYLE_FLOAT = 'styleFloat',
+TRANSPARENT = 'transparent',
+GET_COMPUTED_STYLE = 'getComputedStyle',
+DOCUMENT = Y.config.doc,
+UNDEFINED = undefined,
+re_color = /color$/i;
+Y.mix(Y.DOM, {
+CUSTOM_STYLES: {
+},
+/**
+* Sets a style property for a given element.
+* @method setStyle
+* @param {HTMLElement} An HTMLElement to apply the style to.
+* @param {String} att The style property to set.
+* @param {String|Number} val The value.
+*/
+setStyle: function(node, att, val, style) {
+style = style || node.style;
+var CUSTOM_STYLES = Y.DOM.CUSTOM_STYLES;
+if (style) {
+if (val === null) {
+val = ''; // normalize for unsetting
+}
+if (att in CUSTOM_STYLES) {
+if (CUSTOM_STYLES[att].set) {
+CUSTOM_STYLES[att].set(node, val, style);
+return; // NOTE: return
+} else if (typeof CUSTOM_STYLES[att] === 'string') {
+att = CUSTOM_STYLES[att];
+}
+}
+style[att] = val;
+}
+},
+/**
+* Returns the current style value for the given property.
+* @method getStyle
+* @param {HTMLElement} An HTMLElement to get the style from.
+* @param {String} att The style property to get.
+*/
+getStyle: function(node, att) {
+var style = node[STYLE],
+CUSTOM_STYLES = Y.DOM.CUSTOM_STYLES,
+val = '';
+if (style) {
+if (att in CUSTOM_STYLES) {
+if (CUSTOM_STYLES[att].get) {
+return CUSTOM_STYLES[att].get(node, att, style); // NOTE: return
+} else if (typeof CUSTOM_STYLES[att] === 'string') {
+att = CUSTOM_STYLES[att];
+}
+}
+val = style[att];
+if (val === '') { // TODO: is empty string sufficient?
+val = Y.DOM[GET_COMPUTED_STYLE](node, att);
+}
+}
+return val;
+},
+/**
+* Sets multiple style properties.
+* @method setStyles
+* @param {HTMLElement} node An HTMLElement to apply the styles to.
+* @param {Object} hash An object literal of property:value pairs.
+*/
+setStyles: function(node, hash) {
+var style = node.style;
+Y.each(hash, function(v, n) {
+Y.DOM.setStyle(node, n, v, style);
+}, Y.DOM);
+},
+/**
+* Returns the computed style for the given node.
+* @method getComputedStyle
+* @param {HTMLElement} An HTMLElement to get the style from.
+* @param {String} att The style property to get.
+* @return {String} The computed value of the style property.
+*/
+getComputedStyle: function(node, att) {
+var val = '',
+doc = node[OWNER_DOCUMENT];
+if (node[STYLE]) {
+val = doc[DEFAULT_VIEW][GET_COMPUTED_STYLE](node, null)[att];
+}
+return val;
+}
+});
+// normalize reserved word float alternatives ("cssFloat" or "styleFloat")
+if (DOCUMENT[DOCUMENT_ELEMENT][STYLE][CSS_FLOAT] !== UNDEFINED) {
+Y.DOM.CUSTOM_STYLES[FLOAT] = CSS_FLOAT;
+} else if (DOCUMENT[DOCUMENT_ELEMENT][STYLE][STYLE_FLOAT] !== UNDEFINED) {
+Y.DOM.CUSTOM_STYLES[FLOAT] = STYLE_FLOAT;
+}
+// fix opera computedStyle default color unit (convert to rgb)
+if (Y.UA.opera) {
+Y.DOM[GET_COMPUTED_STYLE] = function(node, att) {
+var view = node[OWNER_DOCUMENT][DEFAULT_VIEW],
+val = view[GET_COMPUTED_STYLE](node, '')[att];
+if (re_color.test(att)) {
+val = Y.Color.toRGB(val);
+}
+return val;
+};
+}
+// safari converts transparent to rgba(), others use "transparent"
+if (Y.UA.webkit) {
+Y.DOM[GET_COMPUTED_STYLE] = function(node, att) {
+var view = node[OWNER_DOCUMENT][DEFAULT_VIEW],
+val = view[GET_COMPUTED_STYLE](node, '')[att];
+if (val === 'rgba(0, 0, 0, 0)') {
+val = TRANSPARENT;
+}
+return val;
+};
+}
+})(Y);
+(function(Y) {
+var TO_STRING = 'toString',
+PARSE_INT = parseInt,
+RE = RegExp;
+Y.Color = {
+KEYWORDS: {
+black: '000',
+silver: 'c0c0c0',
+gray: '808080',
+white: 'fff',
+maroon: '800000',
+red: 'f00',
+purple: '800080',
+fuchsia: 'f0f',
+green: '008000',
+lime: '0f0',
+olive: '808000',
+yellow: 'ff0',
+navy: '000080',
+blue: '00f',
+teal: '008080',
+aqua: '0ff'
+},
+re_RGB: /^rgb\(([0-9]+)\s*,\s*([0-9]+)\s*,\s*([0-9]+)\)$/i,
+re_hex: /^#?([0-9A-F]{2})([0-9A-F]{2})([0-9A-F]{2})$/i,
+re_hex3: /([0-9A-F])/gi,
+toRGB: function(val) {
+if (!Y.Color.re_RGB.test(val)) {
+val = Y.Color.toHex(val);
+}
+if(Y.Color.re_hex.exec(val)) {
+val = 'rgb(' + [
+PARSE_INT(RE.$1, 16),
+PARSE_INT(RE.$2, 16),
+PARSE_INT(RE.$3, 16)
+].join(', ') + ')';
+}
+return val;
+},
+toHex: function(val) {
+val = Y.Color.KEYWORDS[val] || val;
+if (Y.Color.re_RGB.exec(val)) {
+var r = (RE.$1.length === 1) ? '0' + RE.$1 : Number(RE.$1),
+g = (RE.$2.length === 1) ? '0' + RE.$2 : Number(RE.$2),
+b = (RE.$3.length === 1) ? '0' + RE.$3 : Number(RE.$3);
+val = [
+r[TO_STRING](16),
+g[TO_STRING](16),
+b[TO_STRING](16)
+].join('');
+}
+if (val.length < 6) {
+val = val.replace(Y.Color.re_hex3, '$1$1');
+}
+if (val !== 'transparent' && val.indexOf('#') < 0) {
+val = '#' + val;
+}
+return val.toLowerCase();
+}
+};
+})(Y);
+(function(Y) {
+var CLIENT_TOP = 'clientTop',
+CLIENT_LEFT = 'clientLeft',
+HAS_LAYOUT = 'hasLayout',
+PX = 'px',
+FILTER = 'filter',
+FILTERS = 'filters',
+OPACITY = 'opacity',
+AUTO = 'auto',
+BORDER_TOP_WIDTH = 'borderTopWidth',
+BORDER_RIGHT_WIDTH = 'borderRightWidth',
+BORDER_BOTTOM_WIDTH = 'borderBottomWidth',
+BORDER_LEFT_WIDTH = 'borderLeftWidth',
+WIDTH = 'width',
+HEIGHT = 'height',
+TRANSPARENT = 'transparent',
+VISIBLE = 'visible',
+GET_COMPUTED_STYLE = 'getComputedStyle',
+UNDEFINED = undefined,
+documentElement = document.documentElement,
+// TODO: unit-less lineHeight (e.g. 1.22)
+re_size = /^width|height$/,
+re_unit = /^(\d[.\d]*)+(em|ex|px|gd|rem|vw|vh|vm|ch|mm|cm|in|pt|pc|deg|rad|ms|s|hz|khz|%){1}?/i,
+_getStyleObj = function(node) {
+return node.currentStyle || node.style;
+},
+ComputedStyle = {
+CUSTOM_STYLES: {},
+get: function(el, property) {
+var value = '',
+current;
+if (el) {
+current = _getStyleObj(el)[property];
+if (property === OPACITY) {
+value = Y.DOM.CUSTOM_STYLES[OPACITY].get(el);
+} else if (!current || (current.indexOf && current.indexOf(PX) > -1)) { // no need to convert
+value = current;
+} else if (Y.DOM.IE.COMPUTED[property]) { // use compute function
+value = Y.DOM.IE.COMPUTED[property](el, property);
+} else if (re_unit.test(current)) { // convert to pixel
+value = ComputedStyle.getPixel(el, property) + PX;
+} else {
+value = current;
+}
+}
+return value;
+},
+getOffset: function(el, prop) {
+var current = _getStyleObj(el)[prop],                     // value of "width", "top", etc.
+capped = prop.charAt(0).toUpperCase() + prop.substr(1), // "Width", "Top", etc.
+offset = 'offset' + capped,                             // "offsetWidth", "offsetTop", etc.
+pixel = 'pixel' + capped,                               // "pixelWidth", "pixelTop", etc.
+actual,
+value = '';
+if (current === AUTO) {
+actual = el[offset]; // offsetHeight/Top etc.
+if (actual === UNDEFINED) { // likely "right" or "bottom"
+value = 0;
+}
+value = actual;
+if (re_size.test(prop)) { // account for box model diff
+el.style[prop] = actual;
+if (el[offset] > actual) {
+// the difference is padding + border (works in Standards & Quirks modes)
+value = actual - (el[offset] - actual);
+}
+el.style[prop] = AUTO; // revert to auto
+}
+} else { // convert units to px
+if (current.indexOf('%') > -1) { // IE pixelWidth incorrect for percent; manually compute
+current = el.clientWidth - // offsetWidth - borderWidth
+ComputedStyle.getPixel(el, 'paddingRight') -
+ComputedStyle.getPixel(el, 'paddingLeft');
+}
+if (!el.style[pixel] && !el.style[prop]) { // need to map style.width to currentStyle (no currentStyle.pixelWidth)
+el.style[prop] = current;              // no style.pixelWidth if no style.width
+}
+value = el.style[pixel];
+}
+return value + PX;
+},
+getBorderWidth: function(el, property) {
+// clientHeight/Width = paddingBox (e.g. offsetWidth - borderWidth)
+// clientTop/Left = borderWidth
+var value = null;
+if (!el.currentStyle || !el.currentStyle[HAS_LAYOUT]) { // TODO: unset layout?
+el.style.zoom = 1; // need layout to measure client
+}
+switch(property) {
+case BORDER_TOP_WIDTH:
+value = el[CLIENT_TOP];
+break;
+case BORDER_BOTTOM_WIDTH:
+value = el.offsetHeight - el.clientHeight - el[CLIENT_TOP];
+break;
+case BORDER_LEFT_WIDTH:
+value = el[CLIENT_LEFT];
+break;
+case BORDER_RIGHT_WIDTH:
+value = el.offsetWidth - el.clientWidth - el[CLIENT_LEFT];
+break;
+}
+return value + PX;
+},
+getPixel: function(node, att) {
+// use pixelRight to convert to px
+var val = null,
+style = _getStyleObj(node),
+styleRight = style.right,
+current = style[att];
+node.style.right = current;
+val = node.style.pixelRight;
+node.style.right = styleRight; // revert
+return val;
+},
+getMargin: function(node, att) {
+var val,
+style = _getStyleObj(node);
+if (style[att] == AUTO) {
+val = 0;
+} else {
+val = ComputedStyle.getPixel(node, att);
+}
+return val + PX;
+},
+getVisibility: function(node, att) {
+var current;
+while ( (current = node.currentStyle) && current[att] == 'inherit') { // NOTE: assignment in test
+node = node.parentNode;
+}
+return (current) ? current[att] : VISIBLE;
+},
+getColor: function(node, att) {
+var current = _getStyleObj(node)[att];
+if (!current || current === TRANSPARENT) {
+Y.DOM.elementByAxis(node, 'parentNode', null, function(parent) {
+current = _getStyleObj(parent)[att];
+if (current && current !== TRANSPARENT) {
+node = parent;
+return true;
+}
+});
+}
+return Y.Color.toRGB(current);
+},
+getBorderColor: function(node, att) {
+var current = _getStyleObj(node),
+val = current[att] || current.color;
+return Y.Color.toRGB(Y.Color.toHex(val));
+}
+},
+//fontSize: getPixelFont,
+IEComputed = {};
+// use alpha filter for IE opacity
+if (documentElement.style[OPACITY] === UNDEFINED &&
+documentElement[FILTERS]) {
+Y.DOM.CUSTOM_STYLES[OPACITY] = {
+get: function(node) {
+var val = 100;
+try { // will error if no DXImageTransform
+val = node[FILTERS]['DXImageTransform.Microsoft.Alpha'][OPACITY];
+} catch(e) {
+try { // make sure its in the document
+val = node[FILTERS]('alpha')[OPACITY];
+} catch(err) {
+Y.log('getStyle: IE opacity filter not found; returning 1', 'warn', 'dom-style');
+}
+}
+return val / 100;
+},
+set: function(node, val, style) {
+var current,
+styleObj;
+if (val === '') { // normalize inline style behavior
+styleObj = _getStyleObj(node);
+current = (OPACITY in styleObj) ? styleObj[OPACITY] : 1; // revert to original opacity
+val = current;
+}
+if (typeof style[FILTER] == 'string') { // in case not appended
+style[FILTER] = 'alpha(' + OPACITY + '=' + val * 100 + ')';
+if (!node.currentStyle || !node.currentStyle[HAS_LAYOUT]) {
+style.zoom = 1; // needs layout
+}
+}
+}
+};
+}
+try {
+document.createElement('div').style.height = '-1px';
+} catch(e) { // IE throws error on invalid style set; trap common cases
+Y.DOM.CUSTOM_STYLES.height = {
+set: function(node, val, style) {
+if (parseInt(val, 10) >= 0) {
+style.height = val;
+} else {
+Y.log('invalid style value for height: ' + val, 'warn', 'dom-style');
+}
+}
+};
+Y.DOM.CUSTOM_STYLES.width = {
+set: function(node, val, style) {
+if (parseInt(val, 10) >= 0) {
+style.width = val;
+} else {
+Y.log('invalid style value for width: ' + val, 'warn', 'dom-style');
+}
+}
+};
+}
+// TODO: top, right, bottom, left
+IEComputed[WIDTH] = IEComputed[HEIGHT] = ComputedStyle.getOffset;
+IEComputed.color = IEComputed.backgroundColor = ComputedStyle.getColor;
+IEComputed[BORDER_TOP_WIDTH] = IEComputed[BORDER_RIGHT_WIDTH] =
+IEComputed[BORDER_BOTTOM_WIDTH] = IEComputed[BORDER_LEFT_WIDTH] =
+ComputedStyle.getBorderWidth;
+IEComputed.marginTop = IEComputed.marginRight = IEComputed.marginBottom =
+IEComputed.marginLeft = ComputedStyle.getMargin;
+IEComputed.visibility = ComputedStyle.getVisibility;
+IEComputed.borderColor = IEComputed.borderTopColor =
+IEComputed.borderRightColor = IEComputed.borderBottomColor =
+IEComputed.borderLeftColor = ComputedStyle.getBorderColor;
+if (!Y.config.win[GET_COMPUTED_STYLE]) {
+Y.DOM[GET_COMPUTED_STYLE] = ComputedStyle.get;
+}
+Y.namespace('DOM.IE');
+Y.DOM.IE.COMPUTED = IEComputed;
+Y.DOM.IE.ComputedStyle = ComputedStyle;
+})(Y);
+}, '3.0.0b1' ,{skinnable:false, requires:['dom-base']});
+YUI.add('dom-screen', function(Y) {
+(function(Y) {
+/**
+* Adds position and region management functionality to DOM.
+* @module dom
+* @submodule dom-screen
+* @for DOM
+*/
+var DOCUMENT_ELEMENT = 'documentElement',
+COMPAT_MODE = 'compatMode',
+POSITION = 'position',
+FIXED = 'fixed',
+RELATIVE = 'relative',
+LEFT = 'left',
+TOP = 'top',
+_BACK_COMPAT = 'BackCompat',
+MEDIUM = 'medium',
+BORDER_LEFT_WIDTH = 'borderLeftWidth',
+BORDER_TOP_WIDTH = 'borderTopWidth',
+GET_BOUNDING_CLIENT_RECT = 'getBoundingClientRect',
+GET_COMPUTED_STYLE = 'getComputedStyle',
+// TODO: how about thead/tbody/tfoot/tr?
+// TODO: does caption matter?
+RE_TABLE = /^t(?:able|d|h)$/i;
+Y.mix(Y.DOM, {
+/**
+* Returns the inner height of the viewport (exludes scrollbar).
+* @method winHeight
+* @return {Number} The current height of the viewport.
+*/
+winHeight: function(node) {
+var h = Y.DOM._getWinSize(node).height;
+Y.log('winHeight returning ' + h, 'info', 'dom-screen');
+return h;
+},
+/**
+* Returns the inner width of the viewport (exludes scrollbar).
+* @method winWidth
+* @return {Number} The current width of the viewport.
+*/
+winWidth: function(node) {
+var w = Y.DOM._getWinSize(node).width;
+Y.log('winWidth returning ' + w, 'info', 'dom-screen');
+return w;
+},
+/**
+* Document height
+* @method docHeight
+* @return {Number} The current height of the document.
+*/
+docHeight:  function(node) {
+var h = Y.DOM._getDocSize(node).height;
+Y.log('docHeight returning ' + h, 'info', 'dom-screen');
+return Math.max(h, Y.DOM._getWinSize(node).height);
+},
+/**
+* Document width
+* @method docWidth
+* @return {Number} The current width of the document.
+*/
+docWidth:  function(node) {
+var w = Y.DOM._getDocSize(node).width;
+Y.log('docWidth returning ' + w, 'info', 'dom-screen');
+return Math.max(w, Y.DOM._getWinSize(node).width);
+},
+/**
+* Amount page has been scroll horizontally
+* @method docScrollX
+* @return {Number} The current amount the screen is scrolled horizontally.
+*/
+docScrollX: function(node) {
+var doc = Y.DOM._getDoc(node);
+return Math.max(doc[DOCUMENT_ELEMENT].scrollLeft, doc.body.scrollLeft);
+},
+/**
+* Amount page has been scroll vertically
+* @method docScrollY
+* @return {Number} The current amount the screen is scrolled vertically.
+*/
+docScrollY:  function(node) {
+var doc = Y.DOM._getDoc(node);
+return Math.max(doc[DOCUMENT_ELEMENT].scrollTop, doc.body.scrollTop);
+},
+/**
+* Gets the current position of an element based on page coordinates.
+* Element must be part of the DOM tree to have page coordinates
+* (display:none or elements not appended return false).
+* @method getXY
+* @param element The target element
+* @return {Array} The XY position of the element
+TODO: test inDocument/display?
+*/
+getXY: function() {
+if (document[DOCUMENT_ELEMENT][GET_BOUNDING_CLIENT_RECT]) {
+return function(node) {
+var xy = null,
+scrollLeft,
+scrollTop,
+box,
+off1, off2,
+bLeft, bTop,
+mode,
+doc;
+if (node) {
+if (Y.DOM.inDoc(node)) {
+scrollLeft = Y.DOM.docScrollX(node);
+scrollTop = Y.DOM.docScrollY(node);
+box = node[GET_BOUNDING_CLIENT_RECT]();
+doc = Y.DOM._getDoc(node);
+xy = [box.left, box.top];
+if (Y.UA.ie) {
+off1 = 2;
+off2 = 2;
+mode = doc[COMPAT_MODE];
+bLeft = Y.DOM[GET_COMPUTED_STYLE](doc[DOCUMENT_ELEMENT], BORDER_LEFT_WIDTH);
+bTop = Y.DOM[GET_COMPUTED_STYLE](doc[DOCUMENT_ELEMENT], BORDER_TOP_WIDTH);
+if (Y.UA.ie === 6) {
+if (mode !== _BACK_COMPAT) {
+off1 = 0;
+off2 = 0;
+}
+}
+if ((mode == _BACK_COMPAT)) {
+if (bLeft !== MEDIUM) {
+off1 = parseInt(bLeft, 10);
+}
+if (bTop !== MEDIUM) {
+off2 = parseInt(bTop, 10);
+}
+}
+xy[0] -= off1;
+xy[1] -= off2;
+}
+if ((scrollTop || scrollLeft)) {
+xy[0] += scrollLeft;
+xy[1] += scrollTop;
+}
+} else { // default to current offsets
+xy = Y.DOM._getOffset(node);
+}
+}
+return xy;
+};
+} else {
+return function(node) { // manually calculate by crawling up offsetParents
+//Calculate the Top and Left border sizes (assumes pixels)
+var xy = null,
+parentNode,
+bCheck,
+scrollTop,
+scrollLeft;
+if (node) {
+if (Y.DOM.inDoc(node)) {
+xy = [node.offsetLeft, node.offsetTop];
+parentNode = node;
+// TODO: refactor with !! or just falsey
+bCheck = ((Y.UA.gecko || Y.UA.webkit > 519) ? true : false);
+// TODO: worth refactoring for TOP/LEFT only?
+while ((parentNode = parentNode.offsetParent)) {
+xy[0] += parentNode.offsetLeft;
+xy[1] += parentNode.offsetTop;
+if (bCheck) {
+xy = Y.DOM._calcBorders(parentNode, xy);
+}
+}
+// account for any scrolled ancestors
+if (Y.DOM.getStyle(node, POSITION) != FIXED) {
+parentNode = node;
+while ((parentNode = parentNode.parentNode)) {
+scrollTop = parentNode.scrollTop;
+scrollLeft = parentNode.scrollLeft;
+//Firefox does something funky with borders when overflow is not visible.
+if (Y.UA.gecko && (Y.DOM.getStyle(parentNode, 'overflow') !== 'visible')) {
+xy = Y.DOM._calcBorders(parentNode, xy);
+}
+if (scrollTop || scrollLeft) {
+xy[0] -= scrollLeft;
+xy[1] -= scrollTop;
+}
+}
+xy[0] += Y.DOM.docScrollX(node);
+xy[1] += Y.DOM.docScrollY(node);
+} else {
+//Fix FIXED position -- add scrollbars
+xy[0] += Y.DOM.docScrollX(node);
+xy[1] += Y.DOM.docScrollY(node);
+}
+} else {
+xy = Y.DOM._getOffset(node);
+}
+}
+return xy;
+};
+}
+}(),// NOTE: Executing for loadtime branching
+_getOffset: function(node) {
+var pos,
+xy = null;
+if (node) {
+pos = Y.DOM.getStyle(node, POSITION);
+xy = [
+parseInt(Y.DOM[GET_COMPUTED_STYLE](node, LEFT), 10),
+parseInt(Y.DOM[GET_COMPUTED_STYLE](node, TOP), 10)
+];
+if ( isNaN(xy[0]) ) { // in case of 'auto'
+xy[0] = parseInt(Y.DOM.getStyle(node, LEFT), 10); // try inline
+if ( isNaN(xy[0]) ) { // default to offset value
+xy[0] = (pos === RELATIVE) ? 0 : node.offsetLeft || 0;
+}
+}
+if ( isNaN(xy[1]) ) { // in case of 'auto'
+xy[1] = parseInt(Y.DOM.getStyle(node, TOP), 10); // try inline
+if ( isNaN(xy[1]) ) { // default to offset value
+xy[1] = (pos === RELATIVE) ? 0 : node.offsetTop || 0;
+}
+}
+}
+return xy;
+},
+/**
+* Gets the current X position of an element based on page coordinates.
+* Element must be part of the DOM tree to have page coordinates
+* (display:none or elements not appended return false).
+* @method getX
+* @param element The target element
+* @return {Int} The X position of the element
+*/
+getX: function(node) {
+return Y.DOM.getXY(node)[0];
+},
+/**
+* Gets the current Y position of an element based on page coordinates.
+* Element must be part of the DOM tree to have page coordinates
+* (display:none or elements not appended return false).
+* @method getY
+* @param element The target element
+* @return {Int} The Y position of the element
+*/
+getY: function(node) {
+return Y.DOM.getXY(node)[1];
+},
+/**
+* Set the position of an html element in page coordinates.
+* The element must be part of the DOM tree to have page coordinates (display:none or elements not appended return false).
+* @method setXY
+* @param element The target element
+* @param {Array} xy Contains X & Y values for new position (coordinates are page-based)
+* @param {Boolean} noRetry By default we try and set the position a second time if the first fails
+*/
+setXY: function(node, xy, noRetry) {
+var setStyle = Y.DOM.setStyle,
+pos,
+delta,
+newXY,
+currentXY;
+if (node && xy) {
+pos = Y.DOM.getStyle(node, POSITION);
+delta = Y.DOM._getOffset(node);
+if (pos == 'static') { // default to relative
+pos = RELATIVE;
+setStyle(node, POSITION, pos);
+}
+currentXY = Y.DOM.getXY(node);
+if (xy[0] !== null) {
+setStyle(node, LEFT, xy[0] - currentXY[0] + delta[0] + 'px');
+}
+if (xy[1] !== null) {
+setStyle(node, TOP, xy[1] - currentXY[1] + delta[1] + 'px');
+}
+if (!noRetry) {
+newXY = Y.DOM.getXY(node);
+if (newXY[0] !== xy[0] || newXY[1] !== xy[1]) {
+Y.DOM.setXY(node, xy, true);
+}
+}
+Y.log('setXY setting position to ' + xy, 'info', 'dom-screen');
+} else {
+Y.log('setXY failed to set ' + node + ' to ' + xy, 'info', 'dom-screen');
+}
+},
+/**
+* Set the X position of an html element in page coordinates, regardless of how the element is positioned.
+* The element(s) must be part of the DOM tree to have page coordinates (display:none or elements not appended return false).
+* @method setX
+* @param element The target element
+* @param {Int} x The X values for new position (coordinates are page-based)
+*/
+setX: function(node, x) {
+return Y.DOM.setXY(node, [x, null]);
+},
+/**
+* Set the Y position of an html element in page coordinates, regardless of how the element is positioned.
+* The element(s) must be part of the DOM tree to have page coordinates (display:none or elements not appended return false).
+* @method setY
+* @param element The target element
+* @param {Int} y The Y values for new position (coordinates are page-based)
+*/
+setY: function(node, y) {
+return Y.DOM.setXY(node, [null, y]);
+},
+_calcBorders: function(node, xy2) {
+var t = parseInt(Y.DOM[GET_COMPUTED_STYLE](node, BORDER_TOP_WIDTH), 10) || 0,
+l = parseInt(Y.DOM[GET_COMPUTED_STYLE](node, BORDER_LEFT_WIDTH), 10) || 0;
+if (Y.UA.gecko) {
+if (RE_TABLE.test(node.tagName)) {
+t = 0;
+l = 0;
+}
+}
+xy2[0] += l;
+xy2[1] += t;
+return xy2;
+},
+_getWinSize: function(node) {
+var doc = Y.DOM._getDoc(),
+win = doc.defaultView || doc.parentWindow,
+mode = doc[COMPAT_MODE],
+h = win.innerHeight,
+w = win.innerWidth,
+root = doc[DOCUMENT_ELEMENT];
+if ( mode && !Y.UA.opera ) { // IE, Gecko
+if (mode != 'CSS1Compat') { // Quirks
+root = doc.body;
+}
+h = root.clientHeight;
+w = root.clientWidth;
+}
+return { height: h, width: w };
+},
+_getDocSize: function(node) {
+var doc = Y.DOM._getDoc(),
+root = doc[DOCUMENT_ELEMENT];
+if (doc[COMPAT_MODE] != 'CSS1Compat') {
+root = doc.body;
+}
+return { height: root.scrollHeight, width: root.scrollWidth };
+}
+});
+})(Y);
+(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)
+* @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 passes nodes.
+* @method intersect
+* @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 i.e. 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
+* @param {Object} node2 The 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 i.e. 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
+* @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 i.e. 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
+@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);
+}, '3.0.0b1' ,{requires:['dom-base', 'dom-style'], skinnable:false});
+YUI.add('selector-native', function(Y) {
+(function(Y) {
+/**
+* The selector-native module provides support for native querySelector
+* @module dom
+* @submodule selector-native
+* @for Selector
+*/
+/**
+* Provides support for using CSS selectors to query the DOM
+* @class Selector
+* @static
+* @for Selector
+*/
+Y.namespace('Selector'); // allow native module to standalone
+var NativeSelector = {
+_reLead: /^\s*([>+~]|:self)/,
+_reUnSupported: /!./,
+_foundCache: [],
+_supportsNative: function() {
+// whitelist and feature detection to manage
+// future implementations manually
+return ( (Y.UA.ie >= 8 || Y.UA.webkit > 525) &&
+document.querySelectorAll);
+},
+_toArray: function(nodes) { // TODO: move to Y.Array
+var ret = nodes,
+i, len;
+if (!nodes.slice) {
+try {
+ret = Array.prototype.slice.call(nodes);
+} catch(e) { // IE: requires manual copy
+ret = [];
+for (i = 0, len = nodes.length; i < len; ++i) {
+ret[i] = nodes[i];
+}
+}
+}
+return ret;
+},
+_clearFoundCache: function() {
+var foundCache = NativeSelector._foundCache,
+i, len;
+for (i = 0, len = foundCache.length; i < len; ++i) {
+try { // IE no like delete
+delete foundCache[i]._found;
+} catch(e) {
+foundCache[i].removeAttribute('_found');
+}
+}
+foundCache = [];
+},
+_sort: function(nodes) {
+if (nodes) {
+nodes = NativeSelector._toArray(nodes);
+if (nodes.sort) {
+nodes.sort(function(a, b) {
+return Y.DOM.srcIndex(a) - Y.DOM.srcIndex(b);
+});
+}
+}
+return nodes;
+},
+_deDupe: function(nodes) {
+var ret = [],
+cache = NativeSelector._foundCache,
+i, node;
+for (i = 0, node; node = nodes[i++];) {
+if (!node._found) {
+ret[ret.length] = cache[cache.length] = node;
+node._found = true;
+}
+}
+NativeSelector._clearFoundCache();
+return ret;
+},
+// allows element scoped queries to begin with combinator
+// e.g. query('> p', document.body) === query('body > p')
+_prepQuery: function(root, selector) {
+var groups = selector.split(','),
+queries = [],
+isDocRoot = (root && root.nodeType === 9),
+i, len;
+if (root) {
+if (!isDocRoot) {
+root.id = root.id || Y.guid();
+// break into separate queries for element scoping
+for (i = 0, len = groups.length; i < len; ++i) {
+selector = '#' + root.id + ' ' + groups[i]; // prepend with root ID
+queries.push({root: root.ownerDocument, selector: selector});
+}
+} else {
+queries.push({root: root, selector: selector});
+}
+}
+return queries;
+},
+_query: function(selector, root, firstOnly) {
+if (NativeSelector._reUnSupported.test(selector)) {
+return Y.Selector._brute.query(selector, root, firstOnly);
+}
+var ret = firstOnly ? null : [],
+queryName = firstOnly ? 'querySelector' : 'querySelectorAll',
+result,
+queries,
+i, query;
+root = root || Y.config.doc;
+if (selector) {
+queries = NativeSelector._prepQuery(root, selector);
+ret = [];
+for (i = 0, query; query = queries[i++];) {
+try {
+result = query.root[queryName](query.selector);
+if (queryName === 'querySelectorAll') { // convert NodeList to Array
+result = NativeSelector._toArray(result);
+}
+ret = ret.concat(result);
+} catch(e) {
+Y.log('native selector error: ' + e, 'error', 'Selector');
+}
+}
+if (queries.length > 1) { // remove dupes and sort by doc order
+ret = NativeSelector._sort(NativeSelector._deDupe(ret));
+}
+ret = (!firstOnly) ? ret : ret[0] || null;
+}
+return ret;
+},
+_filter: function(nodes, selector) {
+var ret = [],
+i, node;
+if (nodes && selector) {
+for (i = 0, node; (node = nodes[i++]);) {
+if (Y.Selector._test(node, selector)) {
+ret[ret.length] = node;
+}
+}
+} else {
+Y.log('invalid filter input (nodes: ' + nodes +
+', selector: ' + selector + ')', 'warn', 'Selector');
+}
+return ret;
+},
+_test: function(node, selector) {
+var ret = false,
+groups = selector.split(','),
+item,
+i, group;
+if (node && node.tagName) { // only test HTMLElements
+node.id = node.id || Y.guid();
+for (i = 0, group; group = groups[i++];) {
+group += '#' + node.id; // add ID for uniqueness
+item = Y.Selector.query(group, null, true);
+ret = (item === node);
+if (ret) {
+break;
+}
+}
+}
+return ret;
+}
+};
+if (Y.UA.ie && Y.UA.ie <= 8) {
+NativeSelector._reUnSupported = /:(?:nth|not|root|only|checked|first|last|empty)/;
+}
+Y.mix(Y.Selector, NativeSelector, true);
+// allow standalone selector-native module
+if (NativeSelector._supportsNative()) {
+Y.Selector.query = NativeSelector._query;
+//Y.Selector.filter = NativeSelector._filter;
+//Y.Selector.test = NativeSelector._test;
+}
+Y.Selector.test = NativeSelector._test;
+Y.Selector.filter = NativeSelector._filter;
+})(Y);
+}, '3.0.0b1' ,{requires:['dom-base'], skinnable:false});
+YUI.add('selector-css2', function(Y) {
+/**
+* The selector module provides helper methods allowing CSS2 Selectors to be used with DOM elements.
+* @module dom
+* @submodule selector-css2
+* @for Selector
+*/
+/**
+* Provides helper methods for collecting and filtering DOM elements.
+*/
+var PARENT_NODE = 'parentNode',
+TAG_NAME = 'tagName',
+ATTRIBUTES = 'attributes',
+COMBINATOR = 'combinator',
+PSEUDOS = 'pseudos',
+PREVIOUS = 'previous',
+PREVIOUS_SIBLING = 'previousSibling',
+_childCache = [], // cache to cleanup expando node.children
+Selector = Y.Selector,
+SelectorCSS2 = {
+SORT_RESULTS: true,
+_children: function(node) {
+var ret = node.children,
+i, n;
+if (!ret && node[TAG_NAME]) { // only HTMLElements have children
+ret = [];
+for (i = 0, n; n = node.childNodes[i++];) {
+if (n.tagName) {
+ret[ret.length] = n;
+}
+}
+_childCache[_childCache.length] = node;
+node.children = ret;
+}
+return ret || [];
+},
+_regexCache: {},
+_re: {
+attr: /(\[.*\])/g,
+urls: /^(?:href|src)/
+},
+/**
+* Mapping of shorthand tokens to corresponding attribute selector
+* @property shorthand
+* @type object
+*/
+shorthand: {
+'\\#(-?[_a-z]+[-\\w]*)': '[id=$1]',
+'\\.(-?[_a-z]+[-\\w]*)': '[className~=$1]'
+},
+/**
+* List of operators and corresponding boolean functions.
+* These functions are passed the attribute and the current node's value of the attribute.
+* @property operators
+* @type object
+*/
+operators: {
+'': function(node, m) { return Y.DOM.getAttribute(node, m[0]) !== ''; }, // Just test for existence of attribute
+//'': '.+',
+'=': '^{val}$', // equality
+'~=': '(?:^|\\s+){val}(?:\\s+|$)', // space-delimited
+'|=': '^{val}-?' // optional hyphen-delimited
+},
+pseudos: {
+'first-child': function(node) {
+return Y.Selector._children(node[PARENT_NODE])[0] === node;
+}
+},
+_brute: {
+/**
+* Retrieves a set of nodes based on a given CSS selector.
+* @method query
+*
+* @param {string} selector The CSS Selector to test the node against.
+* @param {HTMLElement} root optional An HTMLElement to start the query from. Defaults to Y.config.doc
+* @param {Boolean} firstOnly optional Whether or not to return only the first match.
+* @return {Array} An array of nodes that match the given selector.
+* @static
+*/
+query: function(selector, root, firstOnly) {
+var ret = [];
+if (selector) {
+ret = Selector._query(selector, root, firstOnly);
+}
+Y.log('query: ' + selector + ' returning: ' + ret.length, 'info', 'Selector');
+Selector._cleanup();
+return (firstOnly) ? (ret[0] || null) : ret;
+}
+},
+// TODO: make extensible? events?
+_cleanup: function() {
+for (var i = 0, node; node = _childCache[i++];) {
+delete node.children;
+}
+_childCache = [];
+},
+_query: function(selector, root, firstOnly, deDupe) {
+var ret = [],
+groups = selector.split(','), // TODO: handle comma in attribute/pseudo
+nodes = [],
+tokens,
+token,
+i, len;
+if (groups.length > 1) {
+for (i = 0, len = groups.length; i < len; ++i) {
+ret = ret.concat(arguments.callee(groups[i],
+root, firstOnly, true));
+}
+ret = Selector.SORT_RESULTS ? Selector._sort(ret) : ret;
+Selector._clearFoundCache();
+} else {
+root = root || Y.config.doc;
+if (root.nodeType !== 9) { // enforce element scope
+if (!root.id) {
+root.id = Y.guid();
+}
+// fast-path ID when possible
+if (root.ownerDocument.getElementById(root.id)) {
+selector = '#' + root.id + ' ' + selector;
+root = root.ownerDocument;
+}
+}
+tokens = Selector._tokenize(selector, root);
+token = tokens.pop();
+if (token) {
+if (deDupe) {
+token.deDupe = true; // TODO: better approach?
+}
+if (tokens[0] && tokens[0].id && root.nodeType === 9 && root.getElementById(tokens[0].id)) {
+root = root.getElementById(tokens[0].id);
+}
+// TODO: no prefilter for off-dom id
+if (root && !nodes.length && token.prefilter) {
+nodes = token.prefilter(root, token);
+}
+if (nodes.length) {
+if (firstOnly) {
+Y.Array.some(nodes, Selector._testToken, token);
+} else {
+Y.Array.each(nodes, Selector._testToken, token);
+}
+}
+ret = token.result;
+}
+}
+return ret;
+},
+_testToken: function(node, index, nodes, token) {
+token = token || this;
+var tag = token.tag,
+previous = token[PREVIOUS],
+result = token.result,
+i = 0,
+nextTest = previous && previous[COMBINATOR] ?
+Selector.combinators[previous[COMBINATOR]] :
+null,
+test,
+attr;
+if (//node[TAG_NAME] && // tagName limits to HTMLElements
+(tag === '*' || tag === node[TAG_NAME]) &&
+!(token.last && node._found) ) {
+while ((attr = token.tests[i])) {
+i++;
+test = attr.test;
+if (test.test) {
+if (!test.test(Y.DOM.getAttribute(node, attr.name))) {
+return false;
+}
+} else if (!test(node, attr.match)) {
+return false;
+}
+}
+if (nextTest && !nextTest(node, token)) {
+return false;
+}
+if (token.root && token.root.nodeType !== 9 && !Y.DOM.contains(token.root, node)) {
+return false;
+}
+result[result.length] = node;
+if (token.deDupe && token.last) {
+node._found = true;
+Selector._foundCache.push(node);
+}
+return true;
+}
+return false;
+},
+_getRegExp: function(str, flags) {
+var regexCache = Selector._regexCache;
+flags = flags || '';
+if (!regexCache[str + flags]) {
+regexCache[str + flags] = new RegExp(str, flags);
+}
+return regexCache[str + flags];
+},
+combinators: {
+' ': function(node, token) {
+var test = Selector._testToken,
+previous = token[PREVIOUS];
+while ( (node = node[PARENT_NODE]) ) {
+if (test(node, null, null, previous)) {
+return true;
+}
+}
+return false;
+},
+'>': function(node, token) {
+return Selector._testToken(node[PARENT_NODE], null, null, token[PREVIOUS]);
+},
+'+': function(node, token) {
+var sib = node[PREVIOUS_SIBLING];
+while (sib && sib.nodeType !== 1) {
+sib = sib[PREVIOUS_SIBLING];
+}
+if (sib && Y.Selector._testToken(sib, null, null, token[PREVIOUS])) {
+return true;
+}
+return false;
+}
+},
+_parsers: [
+{
+name: TAG_NAME,
+re: /^((?:-?[_a-z]+[\w-]*)|\*)/i,
+fn: function(token, match) {
+token.tag = match[1].toUpperCase();
+token.prefilter = function(root) {
+return root.getElementsByTagName(token.tag);
+};
+return true;
+}
+},
+{
+name: ATTRIBUTES,
+re: /^\[([a-z]+\w*)+([~\|\^\$\*!=]=?)?['"]?([^\]]*?)['"]?\]/i,
+fn: function(token, match) {
+var val = match[3],
+operator = !(match[2] && val) ? '' : match[2],
+test = Selector.operators[operator];
+// might be a function
+if (typeof test === 'string') {
+test = Selector._getRegExp(test.replace('{val}', val));
+}
+if (match[1] === 'id' && val) { // store ID for fast-path match
+token.id = val;
+token.prefilter = function(root) {
+var doc = root.nodeType === 9 ? root : root.ownerDocument,
+node = doc.getElementById(val);
+return node ? [node] : [];
+};
+} else if (document.documentElement.getElementsByClassName &&
+match[1].indexOf('class') === 0) {
+if (!token.prefilter) {
+token.prefilter = function(root) {
+return root.getElementsByClassName(val);
+};
+test = true; // skip class test
+}
+}
+return test;
+}
+},
+{
+name: COMBINATOR,
+re: /^\s*([>+~]|\s)\s*/,
+fn: function(token, match) {
+token[COMBINATOR] = match[1];
+return !! Selector.combinators[token[COMBINATOR]];
+}
+},
+{
+name: PSEUDOS,
+re: /^:([\-\w]+)(?:\(['"]?(.+)['"]?\))*/i,
+fn: function(token, match) {
+return Selector[PSEUDOS][match[1]];
+}
+}
+],
+_getToken: function(token) {
+return {
+previous: token,
+combinator: ' ',
+tag: '*',
+prefilter: function(root) {
+return root.getElementsByTagName('*');
+},
+tests: [],
+result: []
+};
+},
+/**
+Break selector into token units per simple selector.
+Combinator is attached to the previous token.
+*/
+_tokenize: function(selector, root) {
+selector = selector || '';
+selector = Selector._replaceShorthand(Y.Lang.trim(selector));
+var token = Selector._getToken(),     // one token per simple selector (left selector holds combinator)
+query = selector, // original query for debug report
+tokens = [],    // array of tokens
+found = false,  // whether or not any matches were found this pass
+test,
+match,         // the regex match
+i, parser;
+/*
+Search for selector patterns, store, and strip them from the selector string
+until no patterns match (invalid selector) or we run out of chars.
+Multiple attributes and pseudos are allowed, in any order.
+for example:
+'form:first-child[type=button]:not(button)[lang|=en]'
+*/
+outer:
+do {
+found = false; // reset after full pass
+for (i = 0, parser; parser = Selector._parsers[i++];) {
+if ( (match = parser.re.exec(selector)) ) { // note assignment
+test = parser.fn(token, match);
+if (test) {
+if (test !== true) { // auto-pass
+token.tests.push({
+name: match[1],
+test: test,
+match: match.slice(1)
+});
+}
+found = true;
+selector = selector.replace(match[0], ''); // strip current match from selector
+if (!selector.length || parser.name === COMBINATOR) {
+token.root = root;
+tokens.push(token);
+token = Selector._getToken(token);
+}
+} else {
+found = false;
+break outer;
+}
+}
+}
+} while (found && selector.length);
+if (!found || selector.length) { // not fully parsed
+Y.log('query: ' + query + ' contains unsupported token in: ' + selector, 'warn', 'Selector');
+tokens = [];
+} else if (tokens.length) {
+tokens[tokens.length - 1].last = true;
+}
+return tokens;
+},
+_replaceShorthand: function(selector) {
+var shorthand = Selector.shorthand,
+attrs = selector.match(Selector._re.attr), // pull attributes to avoid false pos on "." and "#"
+re, i, len;
+if (attrs) {
+selector = selector.replace(Selector._re.attr, 'REPLACED_ATTRIBUTE');
+}
+for (re in shorthand) {
+if (shorthand.hasOwnProperty(re)) {
+selector = selector.replace(Selector._getRegExp(re, 'gi'), shorthand[re]);
+}
+}
+if (attrs) {
+for (i = 0, len = attrs.length; i < len; ++i) {
+selector = selector.replace('REPLACED_ATTRIBUTE', attrs[i]);
+}
+}
+return selector;
+}
+};
+Y.mix(Y.Selector, SelectorCSS2, true);
+// only override native when not supported
+if (!Y.Selector._supportsNative()) {
+Y.Selector.query = Selector._brute.query;
+}
+}, '3.0.0b1' ,{requires:['dom-base', 'selector-native'], skinnable:false});
+YUI.add('dom', function(Y){}, '3.0.0b1' ,{skinnable:false, use:['dom-base', 'dom-style', 'dom-screen', 'selector-native', 'selector-css2']});

comt