comt: comparison src/cm/media/js/lib/yui/yui_3.0.0b1/build/dom/dom-base-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-base-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});

comt