(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);
+