text: /**
   * The YUI module contains the components required for building the YUI seed
   * file.  This includes the script loading mechanism, a simple queue, and
   * the core utilities for the library.
   * @module yui
   * @main yui
   * @submodule yui-base
   */
  
  if (typeof YUI != 'undefined') {
      YUI._YUI = YUI;
  }
  
  /**
  The YUI global namespace object.  If YUI is already defined, the
  existing YUI object will not be overwritten so that defined
  namespaces are preserved.  It is the constructor for the object
  the end user interacts with.  As indicated below, each instance
  has full custom event support, but only if the event system
  is available.  This is a self-instantiable factory function.  You
  can invoke it directly like this:
  
       YUI().use('*', function(Y) {
           // ready
       });
  
  But it also works like this:
  
       var Y = YUI();
  
  Configuring the YUI object:
  
      YUI({
          debug: true,
          combine: false
      }).use('node', function(Y) {
          //Node is ready to use
      });
  
  See the API docs for the <a href="config.html">Config</a> class
  for the complete list of supported configuration properties accepted
  by the YUI constuctor.
  
  @class YUI
  @constructor
  @global
  @uses EventTarget
  @param [o]* {Object} 0..n optional configuration objects.  these values
  are store in Y.config.  See <a href="config.html">Config</a> for the list of supported
  properties.
  */
      /*global YUI*/
      /*global YUI_config*/
      var YUI = function() {
          var i = 0,
              Y = this,
              args = arguments,
              l = args.length,
              instanceOf = function(o, type) {
                  return (o && o.hasOwnProperty && (o instanceof type));
              },
              gconf = (typeof YUI_config !== 'undefined') && YUI_config;
  
          if (!(instanceOf(Y, YUI))) {
              Y = new YUI();
          } else {
              // set up the core environment
              Y._init();
  
              /**
                  YUI.GlobalConfig is a master configuration that might span
                  multiple contexts in a non-browser environment.  It is applied
                  first to all instances in all contexts.
                  @property GlobalConfig
                  @type {Object}
                  @global
                  @static
                  @example
  
  
                      YUI.GlobalConfig = {
                          filter: 'debug'
                      };
  
                      YUI().use('node', function(Y) {
                          //debug files used here
                      });
  
                      YUI({
                          filter: 'min'
                      }).use('node', function(Y) {
                          //min files used here
                      });
  
              */
              if (YUI.GlobalConfig) {
                  Y.applyConfig(YUI.GlobalConfig);
              }
  
              /**
                  YUI_config is a page-level config.  It is applied to all
                  instances created on the page.  This is applied after
                  YUI.GlobalConfig, and before the instance level configuration
                  objects.
                  @global
                  @property YUI_config
                  @type {Object}
                  @example
  
  
                      //Single global var to include before YUI seed file
                      YUI_config = {
                          filter: 'debug'
                      };
  
                      YUI().use('node', function(Y) {
                          //debug files used here
                      });
  
                      YUI({
                          filter: 'min'
                      }).use('node', function(Y) {
                          //min files used here
                      });
              */
              if (gconf) {
                  Y.applyConfig(gconf);
              }
  
              // bind the specified additional modules for this instance
              if (!l) {
                  Y._setup();
              }
          }
  
          if (l) {
              // Each instance can accept one or more configuration objects.
              // These are applied after YUI.GlobalConfig and YUI_Config,
              // overriding values set in those config files if there is a '
              // matching property.
              for (; i < l; i++) {
                  Y.applyConfig(args[i]);
              }
  
              Y._setup();
          }
  
          Y.instanceOf = instanceOf;
  
          return Y;
      };
  
  (function() {
  
      var proto, prop,
          VERSION = '@VERSION@',
          PERIOD = '.',
          BASE = 'http://yui.yahooapis.com/',
          /*
              These CSS class names can't be generated by
              getClassName since it is not available at the
              time they are being used.
          */
          DOC_LABEL = 'yui3-js-enabled',
          CSS_STAMP_EL = 'yui3-css-stamp',
          NOOP = function() {},
          SLICE = Array.prototype.slice,
          APPLY_TO_AUTH = { 'io.xdrReady': 1,   // the functions applyTo
                            'io.xdrResponse': 1,   // can call. this should
                            'SWF.eventHandler': 1 }, // be done at build time
          hasWin = (typeof window != 'undefined'),
          win = (hasWin) ? window : null,
          doc = (hasWin) ? win.document : null,
          docEl = doc && doc.documentElement,
          docClass = docEl && docEl.className,
          instances = {},
          time = new Date().getTime(),
          add = function(el, type, fn, capture) {
              if (el && el.addEventListener) {
                  el.addEventListener(type, fn, capture);
              } else if (el && el.attachEvent) {
                  el.attachEvent('on' + type, fn);
              }
          },
          remove = function(el, type, fn, capture) {
              if (el && el.removeEventListener) {
                  // this can throw an uncaught exception in FF
                  try {
                      el.removeEventListener(type, fn, capture);
                  } catch (ex) {}
              } else if (el && el.detachEvent) {
                  el.detachEvent('on' + type, fn);
              }
          },
          handleLoad = function() {
              YUI.Env.windowLoaded = true;
              YUI.Env.DOMReady = true;
              if (hasWin) {
                  remove(window, 'load', handleLoad);
              }
          },
          getLoader = function(Y, o) {
              var loader = Y.Env._loader;
              if (loader) {
                  //loader._config(Y.config);
                  loader.ignoreRegistered = false;
                  loader.onEnd = null;
                  loader.data = null;
                  loader.required = [];
                  loader.loadType = null;
              } else {
                  loader = new Y.Loader(Y.config);
                  Y.Env._loader = loader;
              }
              YUI.Env.core = Y.Array.dedupe([].concat(YUI.Env.core, [ 'loader-base', 'loader-rollup', 'loader-yui3' ]));
  
              return loader;
          },
  
          clobber = function(r, s) {
              for (var i in s) {
                  if (s.hasOwnProperty(i)) {
                      r[i] = s[i];
                  }
              }
          },
  
          ALREADY_DONE = { success: true };
  
  //  Stamp the documentElement (HTML) with a class of "yui-loaded" to
  //  enable styles that need to key off of JS being enabled.
  if (docEl && docClass.indexOf(DOC_LABEL) == -1) {
      if (docClass) {
          docClass += ' ';
      }
      docClass += DOC_LABEL;
      docEl.className = docClass;
  }
  
  if (VERSION.indexOf('@') > -1) {
      VERSION = '3.5.0'; // dev time hack for cdn test
  }
  
  proto = {
      /**
       * Applies a new configuration object to the YUI instance config.
       * This will merge new group/module definitions, and will also
       * update the loader cache if necessary.  Updating Y.config directly
       * will not update the cache.
       * @method applyConfig
       * @param {Object} o the configuration object.
       * @since 3.2.0
       */
      applyConfig: function(o) {
  
          o = o || NOOP;
  
          var attr,
              name,
              // detail,
              config = this.config,
              mods = config.modules,
              groups = config.groups,
              aliases = config.aliases,
              loader = this.Env._loader;
  
          for (name in o) {
              if (o.hasOwnProperty(name)) {
                  attr = o[name];
                  if (mods && name == 'modules') {
                      clobber(mods, attr);
                  } else if (aliases && name == 'aliases') {
                      clobber(aliases, attr);
                  } else if (groups && name == 'groups') {
                      clobber(groups, attr);
                  } else if (name == 'win') {
                      config[name] = (attr && attr.contentWindow) || attr;
                      config.doc = config[name] ? config[name].document : null;
                  } else if (name == '_yuid') {
                      // preserve the guid
                  } else {
                      config[name] = attr;
                  }
              }
          }
  
          if (loader) {
              loader._config(o);
          }
  
      },
      /**
      * Old way to apply a config to the instance (calls `applyConfig` under the hood)
      * @private
      * @method _config
      * @param {Object} o The config to apply
      */
      _config: function(o) {
          this.applyConfig(o);
      },
  
      /**
       * Initialize this YUI instance
       * @private
       * @method _init
       */
      _init: function() {
          var filter, el,
              Y = this,
              G_ENV = YUI.Env,
              Env = Y.Env,
              prop;
  
          /**
           * The version number of the YUI instance.
           * @property version
           * @type string
           */
          Y.version = VERSION;
  
          if (!Env) {
              Y.Env = {
                  core: ['get','features','intl-base','yui-log','yui-later'],
                  mods: {}, // flat module map
                  versions: {}, // version module map
                  base: BASE,
                  cdn: BASE + VERSION + '/build/',
                  // bootstrapped: false,
                  _idx: 0,
                  _used: {},
                  _attached: {},
                  _missed: [],
                  _yidx: 0,
                  _uidx: 0,
                  _guidp: 'y',
                  _loaded: {},
                  // serviced: {},
                  // Regex in English:
                  // I'll start at the \b(simpleyui).
                  // 1. Look in the test string for "simpleyui" or "yui" or
                  //    "yui-base" or "yui-davglass" or "yui-foobar" that comes after a word break.  That is, it
                  //    can't match "foyui" or "i_heart_simpleyui". This can be anywhere in the string.
                  // 2. After #1 must come a forward slash followed by the string matched in #1, so
                  //    "yui-base/yui-base" or "simpleyui/simpleyui" or "yui-pants/yui-pants".
                  // 3. The second occurence of the #1 token can optionally be followed by "-debug" or "-min",
                  //    so "yui/yui-min", "yui/yui-debug", "yui-base/yui-base-debug". NOT "yui/yui-tshirt".
                  // 4. This is followed by ".js", so "yui/yui.js", "simpleyui/simpleyui-min.js"
                  // 0. Going back to the beginning, now. If all that stuff in 1-4 comes after a "?" in the string,
                  //    then capture the junk between the LAST "&" and the string in 1-4.  So
                  //    "blah?foo/yui/yui.js" will capture "foo/" and "blah?some/thing.js&3.3.0/build/yui-davglass/yui-davglass.js"
                  //    will capture "3.3.0/build/"
                  //
                  // Regex Exploded:
                  // (?:\?             Find a ?
                  //   (?:[^&]*&)      followed by 0..n characters followed by an &
                  //   *               in fact, find as many sets of characters followed by a & as you can
                  //   ([^&]*)         capture the stuff after the last & in \1
                  // )?                but it's ok if all this ?junk&more_junk stuff isn't even there
                  // \b(simpleyui|     after a word break find either the string "simpleyui" or
                  //    yui(?:-\w+)?   the string "yui" optionally followed by a -, then more characters
                  // )                 and store the simpleyui or yui-* string in \2
                  // \/\2              then comes a / followed by the simpleyui or yui-* string in \2
                  // (?:-(min|debug))? optionally followed by "-min" or "-debug"
                  // .js               and ending in ".js"
                  _BASE_RE: /(?:\?(?:[^&]*&)*([^&]*))?\b(simpleyui|yui(?:-\w+)?)\/\2(?:-(min|debug))?\.js/,
                  parseBasePath: function(src, pattern) {
                      var match = src.match(pattern),
                          path, filter;
  
                      if (match) {
                          path = RegExp.leftContext || src.slice(0, src.indexOf(match[0]));
  
                          // this is to set up the path to the loader.  The file
                          // filter for loader should match the yui include.
                          filter = match[3];
  
                          // extract correct path for mixed combo urls
                          // http://yuilibrary.com/projects/yui3/ticket/2528423
                          if (match[1]) {
                              path += '?' + match[1];
                          }
                          path = {
                              filter: filter,
                              path: path
                          }
                      }
                      return path;
                  },
                  getBase: G_ENV && G_ENV.getBase ||
                          function(pattern) {
                              var nodes = (doc && doc.getElementsByTagName('script')) || [],
                                  path = Env.cdn, parsed,
                                  i, len, src;
  
                              for (i = 0, len = nodes.length; i < len; ++i) {
                                  src = nodes[i].src;
                                  if (src) {
                                      parsed = Y.Env.parseBasePath(src, pattern);
                                      if (parsed) {
                                          filter = parsed.filter;
                                          path = parsed.path;
                                          break;
                                      }
                                  }
                              }
  
                              // use CDN default
                              return path;
                          }
  
              };
  
              Env = Y.Env;
  
              Env._loaded[VERSION] = {};
  
              if (G_ENV && Y !== YUI) {
                  Env._yidx = ++G_ENV._yidx;
                  Env._guidp = ('yui_' + VERSION + '_' +
                               Env._yidx + '_' + time).replace(/\./g, '_').replace(/-/g, '_');
              } else if (YUI._YUI) {
  
                  G_ENV = YUI._YUI.Env;
                  Env._yidx += G_ENV._yidx;
                  Env._uidx += G_ENV._uidx;
  
                  for (prop in G_ENV) {
                      if (!(prop in Env)) {
                          Env[prop] = G_ENV[prop];
                      }
                  }
  
                  delete YUI._YUI;
              }
  
              Y.id = Y.stamp(Y);
              instances[Y.id] = Y;
  
          }
  
          Y.constructor = YUI;
  
          // configuration defaults
          Y.config = Y.config || {
              bootstrap: true,
              cacheUse: true,
              debug: true,
              doc: doc,
              fetchCSS: true,
              throwFail: true,
              useBrowserConsole: true,
              useNativeES5: true,
              win: win
          };
  
          //Register the CSS stamp element
          if (doc && !doc.getElementById(CSS_STAMP_EL)) {
              el = doc.createElement('div');
              el.innerHTML = '<div id="' + CSS_STAMP_EL + '" style="position: absolute !important; visibility: hidden !important"></div>';
              YUI.Env.cssStampEl = el.firstChild;
              if (doc.body) {
                  doc.body.appendChild(YUI.Env.cssStampEl);
              } else {
                  docEl.insertBefore(YUI.Env.cssStampEl, docEl.firstChild);
              }
          }
  
          Y.config.lang = Y.config.lang || 'en-US';
  
          Y.config.base = YUI.config.base || Y.Env.getBase(Y.Env._BASE_RE);
  
          if (!filter || (!('mindebug').indexOf(filter))) {
              filter = 'min';
          }
          filter = (filter) ? '-' + filter : filter;
          Y.config.loaderPath = YUI.config.loaderPath || 'loader/loader' + filter + '.js';
  
      },
  
      /**
       * Finishes the instance setup. Attaches whatever modules were defined
       * when the yui modules was registered.
       * @method _setup
       * @private
       */
      _setup: function(o) {
          var i, Y = this,
              core = [],
              mods = YUI.Env.mods,
              //extras = Y.config.core || ['get','features','intl-base','yui-log','yui-later'];
              extras = Y.config.core || [].concat(YUI.Env.core); //Clone it..
  
          for (i = 0; i < extras.length; i++) {
              if (mods[extras[i]]) {
                  core.push(extras[i]);
              }
          }
  
          Y._attach(['yui-base']);
          Y._attach(core);
  
          if (Y.Loader) {
              getLoader(Y);
          }
  
      },
  
      /**
       * Executes a method on a YUI instance with
       * the specified id if the specified method is whitelisted.
       * @method applyTo
       * @param id {String} the YUI instance id.
       * @param method {String} the name of the method to exectute.
       * Ex: 'Object.keys'.
       * @param args {Array} the arguments to apply to the method.
       * @return {Object} the return value from the applied method or null.
       */
      applyTo: function(id, method, args) {
          if (!(method in APPLY_TO_AUTH)) {
              this.log(method + ': applyTo not allowed', 'warn', 'yui');
              return null;
          }
  
          var instance = instances[id], nest, m, i;
          if (instance) {
              nest = method.split('.');
              m = instance;
              for (i = 0; i < nest.length; i = i + 1) {
                  m = m[nest[i]];
                  if (!m) {
                      this.log('applyTo not found: ' + method, 'warn', 'yui');
                  }
              }
              return m && m.apply(instance, args);
          }
  
          return null;
      },
  
  /**
  Registers a module with the YUI global.  The easiest way to create a
  first-class YUI module is to use the YUI component build tool.
  
  http://yuilibrary.com/projects/builder
  
  The build system will produce the `YUI.add` wrapper for you module, along
  with any configuration info required for the module.
  @method add
  @param name {String} module name.
  @param fn {Function} entry point into the module that is used to bind module to the YUI instance.
  @param {YUI} fn.Y The YUI instance this module is executed in.
  @param {String} fn.name The name of the module
  @param version {String} version string.
  @param details {Object} optional config data:
  @param details.requires {Array} features that must be present before this module can be attached.
  @param details.optional {Array} optional features that should be present if loadOptional
   is defined.  Note: modules are not often loaded this way in YUI 3,
   but this field is still useful to inform the user that certain
   features in the component will require additional dependencies.
  @param details.use {Array} features that are included within this module which need to
   be attached automatically when this module is attached.  This
   supports the YUI 3 rollup system -- a module with submodules
   defined will need to have the submodules listed in the 'use'
   config.  The YUI component build tool does this for you.
  @return {YUI} the YUI instance.
  @example
  
      YUI.add('davglass', function(Y, name) {
          Y.davglass = function() {
              alert('Dav was here!');
          };
      }, '3.4.0', { requires: ['yui-base', 'harley-davidson', 'mt-dew'] });
  
  */
      add: function(name, fn, version, details) {
          details = details || {};
          var env = YUI.Env,
              mod = {
                  name: name,
                  fn: fn,
                  version: version,
                  details: details
              },
              //Instance hash so we don't apply it to the same instance twice
              applied = {},
              loader, inst,
              i, versions = env.versions;
  
          env.mods[name] = mod;
          versions[version] = versions[version] || {};
          versions[version][name] = mod;
  
          for (i in instances) {
              if (instances.hasOwnProperty(i)) {
                  inst = instances[i];
                  if (!applied[inst.id]) {
                      applied[inst.id] = true;
                      loader = inst.Env._loader;
                      if (loader) {
                          if (!loader.moduleInfo[name] || loader.moduleInfo[name].temp) {
                              loader.addModule(details, name);
                          }
                      }
                  }
              }
          }
  
          return this;
      },
  
      /**
       * Executes the function associated with each required
       * module, binding the module to the YUI instance.
       * @param {Array} r The array of modules to attach
       * @param {Boolean} [moot=false] Don't throw a warning if the module is not attached
       * @method _attach
       * @private
       */
      _attach: function(r, moot) {
          var i, name, mod, details, req, use, after,
              mods = YUI.Env.mods,
              aliases = YUI.Env.aliases,
              Y = this, j,
              cache = YUI.Env._renderedMods,
              loader = Y.Env._loader,
              done = Y.Env._attached,
              len = r.length, loader, def, go,
              c = [];
  
          //Check for conditional modules (in a second+ instance) and add their requirements
          //TODO I hate this entire method, it needs to be fixed ASAP (3.5.0) ^davglass
          for (i = 0; i < len; i++) {
              name = r[i];
              mod = mods[name];
              c.push(name);
              if (loader && loader.conditions[name]) {
                  for (j in loader.conditions[name]) {
                      if (loader.conditions[name].hasOwnProperty(j)) {
                          def = loader.conditions[name][j];
                          go = def && ((def.ua && Y.UA[def.ua]) || (def.test && def.test(Y)));
                          if (go) {
                              c.push(def.name);
                          }
                      }
                  }
              }
          }
          r = c;
          len = r.length;
  
          for (i = 0; i < len; i++) {
              if (!done[r[i]]) {
                  name = r[i];
                  mod = mods[name];
  
                  if (aliases && aliases[name] && !mod) {
                      Y._attach(aliases[name]);
                      continue;
                  }
                  if (!mod) {
                      if (loader && loader.moduleInfo[name]) {
                          mod = loader.moduleInfo[name];
                          moot = true;
                      }
  
  
                      //if (!loader || !loader.moduleInfo[name]) {
                      //if ((!loader || !loader.moduleInfo[name]) && !moot) {
                      if (!moot && name) {
                          if ((name.indexOf('skin-') === -1) && (name.indexOf('css') === -1)) {
                              Y.Env._missed.push(name);
                              Y.Env._missed = Y.Array.dedupe(Y.Env._missed);
                              Y.message('NOT loaded: ' + name, 'warn', 'yui');
                          }
                      }
                  } else {
                      done[name] = true;
                      //Don't like this, but in case a mod was asked for once, then we fetch it
                      //We need to remove it from the missed list ^davglass
                      for (j = 0; j < Y.Env._missed.length; j++) {
                          if (Y.Env._missed[j] === name) {
                              Y.message('Found: ' + name + ' (was reported as missing earlier)', 'warn', 'yui');
                              Y.Env._missed.splice(j, 1);
                          }
                      }
                      /*
                          If it's a temp module, we need to redo it's requirements if it's already loaded
                          since it may have been loaded by another instance and it's dependencies might
                          have been redefined inside the fetched file.
                      */
                      if (loader && cache && cache[name] && cache[name].temp) {
                          loader.getRequires(cache[name]);
                          req = [];
                          for (j in loader.moduleInfo[name].expanded_map) {
                              if (loader.moduleInfo[name].expanded_map.hasOwnProperty(j)) {
                                  req.push(j);
                              }
                          }
                          Y._attach(req);
                      }
                      
                      details = mod.details;
                      req = details.requires;
                      use = details.use;
                      after = details.after;
                      //Force Intl load if there is a language (Loader logic) @todo fix this shit
                      if (details.lang) {
                          req = req || [];
                          req.unshift('intl');
                      }
  
                      if (req) {
                          for (j = 0; j < req.length; j++) {
                              if (!done[req[j]]) {
                                  if (!Y._attach(req)) {
                                      return false;
                                  }
                                  break;
                              }
                          }
                      }
  
                      if (after) {
                          for (j = 0; j < after.length; j++) {
                              if (!done[after[j]]) {
                                  if (!Y._attach(after, true)) {
                                      return false;
                                  }
                                  break;
                              }
                          }
                      }
  
                      if (mod.fn) {
                              if (Y.config.throwFail) {
                                  mod.fn(Y, name);
                              } else {
                                  try {
                                      mod.fn(Y, name);
                                  } catch (e) {
                                      Y.error('Attach error: ' + name, e, name);
                                  return false;
                              }
                          }
                      }
  
                      if (use) {
                          for (j = 0; j < use.length; j++) {
                              if (!done[use[j]]) {
                                  if (!Y._attach(use)) {
                                      return false;
                                  }
                                  break;
                              }
                          }
                      }
  
  
  
                  }
              }
          }
  
          return true;
      },
      /**
      * Delays the `use` callback until another event has taken place. Like: window.onload, domready, contentready, available.
      * @private
      * @method _delayCallback
      * @param {Callback} cb The original `use` callback
      * @param {String|Object} until Either an event (load, domready) or an Object containing event/args keys for contentready/available
      */
      _delayCallback: function(cb, until) {
  
          var Y = this,
              mod = ['event-base'];
  
          until = (Y.Lang.isObject(until) ? until : { event: until });
  
          if (until.event === 'load') {
              mod.push('event-synthetic');
          }
  
          return function() {
              var args = arguments;
              Y._use(mod, function() {
                  Y.on(until.event, function() {
                      args[1].delayUntil = until.event;
                      cb.apply(Y, args);
                  }, until.args);
              });
          };
      },
  
      /**
       * Attaches one or more modules to the YUI instance.  When this
       * is executed, the requirements are analyzed, and one of
       * several things can happen:
       *
       *  * All requirements are available on the page --  The modules
       *   are attached to the instance.  If supplied, the use callback
       *   is executed synchronously.
       *
       *  * Modules are missing, the Get utility is not available OR
       *   the 'bootstrap' config is false -- A warning is issued about
       *   the missing modules and all available modules are attached.
       *
       *  * Modules are missing, the Loader is not available but the Get
       *   utility is and boostrap is not false -- The loader is bootstrapped
       *   before doing the following....
       *
       *  * Modules are missing and the Loader is available -- The loader
       *   expands the dependency tree and fetches missing modules.  When
       *   the loader is finshed the callback supplied to use is executed
       *   asynchronously.
       *
       * @method use
       * @param modules* {String|Array} 1-n modules to bind (uses arguments array).
       * @param [callback] {Function} callback function executed when
       * the instance has the required functionality.  If included, it
       * must be the last parameter.
       * @param callback.Y {YUI} The `YUI` instance created for this sandbox
       * @param callback.status {Object} Object containing `success`, `msg` and `data` properties
       *
       * @example
       *      // loads and attaches dd and its dependencies
       *      YUI().use('dd', function(Y) {});
       *
       *      // loads and attaches dd and node as well as all of their dependencies (since 3.4.0)
       *      YUI().use(['dd', 'node'], function(Y) {});
       *
       *      // attaches all modules that are available on the page
       *      YUI().use('*', function(Y) {});
       *
       *      // intrinsic YUI gallery support (since 3.1.0)
       *      YUI().use('gallery-yql', function(Y) {});
       *
       *      // intrinsic YUI 2in3 support (since 3.1.0)
       *      YUI().use('yui2-datatable', function(Y) {});
       *
       * @return {YUI} the YUI instance.
       */
      use: function() {
          var args = SLICE.call(arguments, 0),
              callback = args[args.length - 1],
              Y = this,
              i = 0,
              a = [],
              name,
              Env = Y.Env,
              provisioned = true;
  
          // The last argument supplied to use can be a load complete callback
          if (Y.Lang.isFunction(callback)) {
              args.pop();
              if (Y.config.delayUntil) {
                  callback = Y._delayCallback(callback, Y.config.delayUntil);
              }
          } else {
              callback = null;
          }
          if (Y.Lang.isArray(args[0])) {
              args = args[0];
          }
  
          if (Y.config.cacheUse) {
              while ((name = args[i++])) {
                  if (!Env._attached[name]) {
                      provisioned = false;
                      break;
                  }
              }
  
              if (provisioned) {
                  if (args.length) {
                  }
                  Y._notify(callback, ALREADY_DONE, args);
                  return Y;
              }
          }
  
          if (Y._loading) {
              Y._useQueue = Y._useQueue || new Y.Queue();
              Y._useQueue.add([args, callback]);
          } else {
              Y._use(args, function(Y, response) {
                  Y._notify(callback, response, args);
              });
          }
  
          return Y;
      },
      /**
      * Notify handler from Loader for attachment/load errors
      * @method _notify
      * @param callback {Function} The callback to pass to the `Y.config.loadErrorFn`
      * @param response {Object} The response returned from Loader
      * @param args {Array} The aruments passed from Loader
      * @private
      */
      _notify: function(callback, response, args) {
          if (!response.success && this.config.loadErrorFn) {
              this.config.loadErrorFn.call(this, this, callback, response, args);
          } else if (callback) {
              if (this.Env._missed && this.Env._missed.length) {
                  response.msg = 'Missing modules: ' + this.Env._missed.join();
                  response.success = false;
              }
              if (this.config.throwFail) {
                  callback(this, response);
              } else {
                  try {
                      callback(this, response);
                  } catch (e) {
                      this.error('use callback error', e, args);
                  }
              }
          }
      },
  
      /**
      * This private method is called from the `use` method queue. To ensure that only one set of loading
      * logic is performed at a time.
      * @method _use
      * @private
      * @param args* {String} 1-n modules to bind (uses arguments array).
      * @param *callback {Function} callback function executed when
      * the instance has the required functionality.  If included, it
      * must be the last parameter.
      */
      _use: function(args, callback) {
  
          if (!this.Array) {
              this._attach(['yui-base']);
          }
  
          var len, loader, handleBoot, handleRLS,
              Y = this,
              G_ENV = YUI.Env,
              mods = G_ENV.mods,
              Env = Y.Env,
              used = Env._used,
              aliases = G_ENV.aliases,
              queue = G_ENV._loaderQueue,
              firstArg = args[0],
              YArray = Y.Array,
              config = Y.config,
              boot = config.bootstrap,
              missing = [],
              i,
              r = [],
              ret = true,
              fetchCSS = config.fetchCSS,
              process = function(names, skip) {
  
                  var i = 0, a = [], name, len, m, req, use;
  
                  if (!names.length) {
                      return;
                  }
  
                  if (aliases) {
                      len = names.length;
                      for (i = 0; i < len; i++) {
                          if (aliases[names[i]] && !mods[names[i]]) {
                              a = [].concat(a, aliases[names[i]]);
                          } else {
                              a.push(names[i]);
                          }
                      }
                      names = a;
                  }
                  
                  len = names.length;
                  
                  for (i = 0; i < len; i++) {
                      name = names[i];
                      if (!skip) {
                          r.push(name);
                      }
  
                      // only attach a module once
                      if (used[name]) {
                          continue;
                      }
                      
                      m = mods[name];
                      req = null;
                      use = null;
  
                      if (m) {
                          used[name] = true;
                          req = m.details.requires;
                          use = m.details.use;
                      } else {
                          // CSS files don't register themselves, see if it has
                          // been loaded
                          if (!G_ENV._loaded[VERSION][name]) {
                              missing.push(name);
                          } else {
                              used[name] = true; // probably css
                          }
                      }
  
                      // make sure requirements are attached
                      if (req && req.length) {
                          process(req);
                      }
  
                      // make sure we grab the submodule dependencies too
                      if (use && use.length) {
                          process(use, 1);
                      }
                  }
  
              },
  
              handleLoader = function(fromLoader) {
                  var response = fromLoader || {
                          success: true,
                          msg: 'not dynamic'
                      },
                      redo, origMissing,
                      ret = true,
                      data = response.data;
  
                  Y._loading = false;
  
                  if (data) {
                      origMissing = missing;
                      missing = [];
                      r = [];
                      process(data);
                      redo = missing.length;
                      if (redo) {
                          if ([].concat(missing).sort().join() ==
                                  origMissing.sort().join()) {
                              redo = false;
                          }
                      }
                  }
  
                  if (redo && data) {
                      Y._loading = true;
                      Y._use(missing, function() {
                          if (Y._attach(data)) {
                              Y._notify(callback, response, data);
                          }
                      });
                  } else {
                      if (data) {
                          ret = Y._attach(data);
                      }
                      if (ret) {
                          Y._notify(callback, response, args);
                      }
                  }
  
                  if (Y._useQueue && Y._useQueue.size() && !Y._loading) {
                      Y._use.apply(Y, Y._useQueue.next());
                  }
  
              };
  
  
          // YUI().use('*'); // bind everything available
          if (firstArg === '*') {
              args = [];
              for (i in mods) {
                  if (mods.hasOwnProperty(i)) {
                      args.push(i);
                  }
              }
              ret = Y._attach(args);
              if (ret) {
                  handleLoader();
              }
              return Y;
          }
  
          if (mods['loader'] && !Y.Loader) {
              Y._attach(['loader']);
          }
  
  
          // use loader to expand dependencies and sort the
          // requirements if it is available.
          if (boot && Y.Loader && args.length) {
              loader = getLoader(Y);
              loader.require(args);
              loader.ignoreRegistered = true;
              loader._boot = true;
              loader.calculate(null, (fetchCSS) ? null : 'js');
              args = loader.sorted;
              loader._boot = false;
          }
          
          process(args);
  
          len = missing.length;
  
  
          if (len) {
              missing = YArray.dedupe(missing);
              len = missing.length;
          }
  
  
          // dynamic load
          if (boot && len && Y.Loader) {
              Y._loading = true;
              loader = getLoader(Y);
              loader.onEnd = handleLoader;
              loader.context = Y;
              loader.data = args;
              loader.ignoreRegistered = false;
              loader.require(args);
              loader.insert(null, (fetchCSS) ? null : 'js');
  
          } else if (boot && len && Y.Get && !Env.bootstrapped) {
  
              Y._loading = true;
  
              handleBoot = function() {
                  Y._loading = false;
                  queue.running = false;
                  Env.bootstrapped = true;
                  G_ENV._bootstrapping = false;
                  if (Y._attach(['loader'])) {
                      Y._use(args, callback);
                  }
              };
  
              if (G_ENV._bootstrapping) {
                  queue.add(handleBoot);
              } else {
                  G_ENV._bootstrapping = true;
                  Y.Get.script(config.base + config.loaderPath, {
                      onEnd: handleBoot
                  });
              }
  
          } else {
              ret = Y._attach(args);
              if (ret) {
                  handleLoader();
              }
          }
  
          return Y;
      },
  
  
      /**
      Adds a namespace object onto the YUI global if called statically.
  
          // creates YUI.your.namespace.here as nested objects
          YUI.namespace("your.namespace.here");
  
      If called as a method on a YUI <em>instance</em>, it creates the
      namespace on the instance.
  
           // creates Y.property.package
           Y.namespace("property.package");
  
      Dots in the input string cause `namespace` to create nested objects for
      each token. If any part of the requested namespace already exists, the
      current object will be left in place.  This allows multiple calls to
      `namespace` to preserve existing namespaced properties.
  
      If the first token in the namespace string is "YAHOO", the token is
      discarded.
  
      Be careful with namespace tokens. Reserved words may work in some browsers
      and not others. For instance, the following will fail in some browsers
      because the supported version of JavaScript reserves the word "long":
  
           Y.namespace("really.long.nested.namespace");
  
      <em>Note: If you pass multiple arguments to create multiple namespaces, only
      the last one created is returned from this function.</em>
  
      @method namespace
      @param  {String} namespace* namespaces to create.
      @return {Object}  A reference to the last namespace object created.
      **/
      namespace: function() {
          var a = arguments, o, i = 0, j, d, arg;
  
          for (; i < a.length; i++) {
              o = this; //Reset base object per argument or it will get reused from the last
              arg = a[i];
              if (arg.indexOf(PERIOD) > -1) { //Skip this if no "." is present
                  d = arg.split(PERIOD);
                  for (j = (d[0] == 'YAHOO') ? 1 : 0; j < d.length; j++) {
                      o[d[j]] = o[d[j]] || {};
                      o = o[d[j]];
                  }
              } else {
                  o[arg] = o[arg] || {};
                  o = o[arg]; //Reset base object to the new object so it's returned
              }
          }
          return o;
      },
  
      // this is replaced if the log module is included
      log: NOOP,
      message: NOOP,
      // this is replaced if the dump module is included
      dump: function (o) { return ''+o; },
  
      /**
       * Report an error.  The reporting mechanism is controlled by
       * the `throwFail` configuration attribute.  If throwFail is
       * not specified, the message is written to the Logger, otherwise
       * a JS error is thrown. If an `errorFn` is specified in the config
       * it must return `true` to keep the error from being thrown.
       * @method error
       * @param msg {String} the error message.
       * @param e {Error|String} Optional JS error that was caught, or an error string.
       * @param src Optional additional info (passed to `Y.config.errorFn` and `Y.message`)
       * and `throwFail` is specified, this error will be re-thrown.
       * @return {YUI} this YUI instance.
       */
      error: function(msg, e, src) {
          //TODO Add check for window.onerror here
  
          var Y = this, ret;
  
          if (Y.config.errorFn) {
              ret = Y.config.errorFn.apply(Y, arguments);
          }
  
          if (!ret) {
              throw (e || new Error(msg));
          } else {
              Y.message(msg, 'error', ''+src); // don't scrub this one
          }
  
          return Y;
      },
  
      /**
       * Generate an id that is unique among all YUI instances
       * @method guid
       * @param pre {String} optional guid prefix.
       * @return {String} the guid.
       */
      guid: function(pre) {
          var id = this.Env._guidp + '_' + (++this.Env._uidx);
          return (pre) ? (pre + id) : id;
      },
  
      /**
       * Returns a `guid` associated with an object.  If the object
       * does not have one, a new one is created unless `readOnly`
       * is specified.
       * @method stamp
       * @param o {Object} The object to stamp.
       * @param readOnly {Boolean} if `true`, a valid guid will only
       * be returned if the object has one assigned to it.
       * @return {String} The object's guid or null.
       */
      stamp: function(o, readOnly) {
          var uid;
          if (!o) {
              return o;
          }
  
          // IE generates its own unique ID for dom nodes
          // The uniqueID property of a document node returns a new ID
          if (o.uniqueID && o.nodeType && o.nodeType !== 9) {
              uid = o.uniqueID;
          } else {
              uid = (typeof o === 'string') ? o : o._yuid;
          }
  
          if (!uid) {
              uid = this.guid();
              if (!readOnly) {
                  try {
                      o._yuid = uid;
                  } catch (e) {
                      uid = null;
                  }
              }
          }
          return uid;
      },
  
      /**
       * Destroys the YUI instance
       * @method destroy
       * @since 3.3.0
       */
      destroy: function() {
          var Y = this;
          if (Y.Event) {
              Y.Event._unload();
          }
          delete instances[Y.id];
          delete Y.Env;
          delete Y.config;
      }
  
      /**
       * instanceof check for objects that works around
       * memory leak in IE when the item tested is
       * window/document
       * @method instanceOf
       * @param o {Object} The object to check.
       * @param type {Object} The class to check against.
       * @since 3.3.0
       */
  };
  
      YUI.prototype = proto;
  
      // inheritance utilities are not available yet
      for (prop in proto) {
          if (proto.hasOwnProperty(prop)) {
              YUI[prop] = proto[prop];
          }
      }
  
      /**
  Static method on the Global YUI object to apply a config to all YUI instances.
  It's main use case is "mashups" where several third party scripts are trying to write to
  a global YUI config at the same time. This way they can all call `YUI.applyConfig({})` instead of
  overwriting other scripts configs.
  @static
  @since 3.5.0
  @method applyConfig
  @param {Object} o the configuration object.
  @example
  
      YUI.applyConfig({
          modules: {
              davglass: {
                  fullpath: './davglass.js'
              }
          }
      });
  
      YUI.applyConfig({
          modules: {
              foo: {
                  fullpath: './foo.js'
              }
          }
      });
  
      YUI().use('davglass', function(Y) {
          //Module davglass will be available here..
      });
  
      */
      YUI.applyConfig = function(o) {
          if (!o) {
              return;
          }
          //If there is a GlobalConfig, apply it first to set the defaults
          if (YUI.GlobalConfig) {
              this.prototype.applyConfig.call(this, YUI.GlobalConfig);
          }
          //Apply this config to it
          this.prototype.applyConfig.call(this, o);
          //Reset GlobalConfig to the combined config
          YUI.GlobalConfig = this.config;
      };
  
      // set up the environment
      YUI._init();
  
      if (hasWin) {
          // add a window load event at load time so we can capture
          // the case where it fires before dynamic loading is
          // complete.
          add(window, 'load', handleLoad);
      } else {
          handleLoad();
      }
  
      YUI.Env.add = add;
      YUI.Env.remove = remove;
  
      /*global exports*/
      // Support the CommonJS method for exporting our single global
      if (typeof exports == 'object') {
          exports.YUI = YUI;
      }
  
  }());
  
  
  /**
   * The config object contains all of the configuration options for
   * the `YUI` instance.  This object is supplied by the implementer
   * when instantiating a `YUI` instance.  Some properties have default
   * values if they are not supplied by the implementer.  This should
   * not be updated directly because some values are cached.  Use
   * `applyConfig()` to update the config object on a YUI instance that
   * has already been configured.
   *
   * @class config
   * @static
   */
  
  /**
   * Allows the YUI seed file to fetch the loader component and library
   * metadata to dynamically load additional dependencies.
   *
   * @property bootstrap
   * @type boolean
   * @default true
   */
  
  /**
   * Turns on writing Ylog messages to the browser console.
   *
   * @property debug
   * @type boolean
   * @default true
   */
  
  /**
   * Log to the browser console if debug is on and the browser has a
   * supported console.
   *
   * @property useBrowserConsole
   * @type boolean
   * @default true
   */
  
  /**
   * A hash of log sources that should be logged.  If specified, only
   * log messages from these sources will be logged.
   *
   * @property logInclude
   * @type object
   */
  
  /**
   * A hash of log sources that should be not be logged.  If specified,
   * all sources are logged if not on this list.
   *
   * @property logExclude
   * @type object
   */
  
  /**
   * Set to true if the yui seed file was dynamically loaded in
   * order to bootstrap components relying on the window load event
   * and the `domready` custom event.
   *
   * @property injected
   * @type boolean
   * @default false
   */
  
  /**
   * If `throwFail` is set, `Y.error` will generate or re-throw a JS Error.
   * Otherwise the failure is logged.
   *
   * @property throwFail
   * @type boolean
   * @default true
   */
  
  /**
   * The window/frame that this instance should operate in.
   *
   * @property win
   * @type Window
   * @default the window hosting YUI
   */
  
  /**
   * The document associated with the 'win' configuration.
   *
   * @property doc
   * @type Document
   * @default the document hosting YUI
   */
  
  /**
   * A list of modules that defines the YUI core (overrides the default list).
   *
   * @property core
   * @type Array
   * @default [ get,features,intl-base,yui-log,yui-later,loader-base, loader-rollup, loader-yui3 ]
   */
  
  /**
   * A list of languages in order of preference. This list is matched against
   * the list of available languages in modules that the YUI instance uses to
   * determine the best possible localization of language sensitive modules.
   * Languages are represented using BCP 47 language tags, such as "en-GB" for
   * English as used in the United Kingdom, or "zh-Hans-CN" for simplified
   * Chinese as used in China. The list can be provided as a comma-separated
   * list or as an array.
   *
   * @property lang
   * @type string|string[]
   */
  
  /**
   * The default date format
   * @property dateFormat
   * @type string
   * @deprecated use configuration in `DataType.Date.format()` instead.
   */
  
  /**
   * The default locale
   * @property locale
   * @type string
   * @deprecated use `config.lang` instead.
   */
  
  /**
   * The default interval when polling in milliseconds.
   * @property pollInterval
   * @type int
   * @default 20
   */
  
  /**
   * The number of dynamic nodes to insert by default before
   * automatically removing them.  This applies to script nodes
   * because removing the node will not make the evaluated script
   * unavailable.  Dynamic CSS is not auto purged, because removing
   * a linked style sheet will also remove the style definitions.
   * @property purgethreshold
   * @type int
   * @default 20
   */
  
  /**
   * The default interval when polling in milliseconds.
   * @property windowResizeDelay
   * @type int
   * @default 40
   */
  
  /**
   * Base directory for dynamic loading
   * @property base
   * @type string
   */
  
  /*
   * The secure base dir (not implemented)
   * For dynamic loading.
   * @property secureBase
   * @type string
   */
  
  /**
   * The YUI combo service base dir. Ex: `http://yui.yahooapis.com/combo?`
   * For dynamic loading.
   * @property comboBase
   * @type string
   */
  
  /**
   * The root path to prepend to module path for the combo service.
   * Ex: 3.0.0b1/build/
   * For dynamic loading.
   * @property root
   * @type string
   */
  
  /**
   * A filter to apply to result urls.  This filter will modify the default
   * path for all modules.  The default path for the YUI library is the
   * minified version of the files (e.g., event-min.js).  The filter property
   * can be a predefined filter or a custom filter.  The valid predefined
   * filters are:
   * <dl>
   *  <dt>DEBUG</dt>
   *  <dd>Selects the debug versions of the library (e.g., event-debug.js).
   *      This option will automatically include the Logger widget</dd>
   *  <dt>RAW</dt>
   *  <dd>Selects the non-minified version of the library (e.g., event.js).</dd>
   * </dl>
   * You can also define a custom filter, which must be an object literal
   * containing a search expression and a replace string:
   *
   *      myFilter: {
   *          'searchExp': "-min\\.js",
   *          'replaceStr': "-debug.js"
   *      }
   *
   * For dynamic loading.
   *
   * @property filter
   * @type string|object
   */
  
  /**
   * The `skin` config let's you configure application level skin
   * customizations.  It contains the following attributes which
   * can be specified to override the defaults:
   *
   *      // The default skin, which is automatically applied if not
   *      // overriden by a component-specific skin definition.
   *      // Change this in to apply a different skin globally
   *      defaultSkin: 'sam',
   *
   *      // This is combined with the loader base property to get
   *      // the default root directory for a skin.
   *      base: 'assets/skins/',
   *
   *      // Any component-specific overrides can be specified here,
   *      // making it possible to load different skins for different
   *      // components.  It is possible to load more than one skin
   *      // for a given component as well.
   *      overrides: {
   *          slider: ['capsule', 'round']
   *      }
   *
   * For dynamic loading.
   *
   *  @property skin
   */
  
  /**
   * Hash of per-component filter specification.  If specified for a given
   * component, this overrides the filter config.
   *
   * For dynamic loading.
   *
   * @property filters
   */
  
  /**
   * Use the YUI combo service to reduce the number of http connections
   * required to load your dependencies.  Turning this off will
   * disable combo handling for YUI and all module groups configured
   * with a combo service.
   *
   * For dynamic loading.
   *
   * @property combine
   * @type boolean
   * @default true if 'base' is not supplied, false if it is.
   */
  
  /**
   * A list of modules that should never be dynamically loaded
   *
   * @property ignore
   * @type string[]
   */
  
  /**
   * A list of modules that should always be loaded when required, even if already
   * present on the page.
   *
   * @property force
   * @type string[]
   */
  
  /**
   * Node or id for a node that should be used as the insertion point for new
   * nodes.  For dynamic loading.
   *
   * @property insertBefore
   * @type string
   */
  
  /**
   * Object literal containing attributes to add to dynamically loaded script
   * nodes.
   * @property jsAttributes
   * @type string
   */
  
  /**
   * Object literal containing attributes to add to dynamically loaded link
   * nodes.
   * @property cssAttributes
   * @type string
   */
  
  /**
   * Number of milliseconds before a timeout occurs when dynamically
   * loading nodes. If not set, there is no timeout.
   * @property timeout
   * @type int
   */
  
  /**
   * Callback for the 'CSSComplete' event.  When dynamically loading YUI
   * components with CSS, this property fires when the CSS is finished
   * loading but script loading is still ongoing.  This provides an
   * opportunity to enhance the presentation of a loading page a little
   * bit before the entire loading process is done.
   *
   * @property onCSS
   * @type function
   */
  
  /**
   * A hash of module definitions to add to the list of YUI components.
   * These components can then be dynamically loaded side by side with
   * YUI via the `use()` method. This is a hash, the key is the module
   * name, and the value is an object literal specifying the metdata
   * for the module.  See `Loader.addModule` for the supported module
   * metadata fields.  Also see groups, which provides a way to
   * configure the base and combo spec for a set of modules.
   *
   *      modules: {
   *          mymod1: {
   *              requires: ['node'],
   *              fullpath: '/mymod1/mymod1.js'
   *          },
   *          mymod2: {
   *              requires: ['mymod1'],
   *              fullpath: '/mymod2/mymod2.js'
   *          },
   *          mymod3: '/js/mymod3.js',
   *          mycssmod: '/css/mycssmod.css'
   *      }
   *
   *
   * @property modules
   * @type object
   */
  
  /**
   * Aliases are dynamic groups of modules that can be used as
   * shortcuts.
   *
   *      YUI({
   *          aliases: {
   *              davglass: [ 'node', 'yql', 'dd' ],
   *              mine: [ 'davglass', 'autocomplete']
   *          }
   *      }).use('mine', function(Y) {
   *          //Node, YQL, DD &amp; AutoComplete available here..
   *      });
   *
   * @property aliases
   * @type object
   */
  
  /**
   * A hash of module group definitions.  It for each group you
   * can specify a list of modules and the base path and
   * combo spec to use when dynamically loading the modules.
   *
   *      groups: {
   *          yui2: {
   *              // specify whether or not this group has a combo service
   *              combine: true,
   *
   *              // The comboSeperator to use with this group's combo handler
   *              comboSep: ';',
   *
   *              // The maxURLLength for this server
   *              maxURLLength: 500,
   *
   *              // the base path for non-combo paths
   *              base: 'http://yui.yahooapis.com/2.8.0r4/build/',
   *
   *              // the path to the combo service
   *              comboBase: 'http://yui.yahooapis.com/combo?',
   *
   *              // a fragment to prepend to the path attribute when
   *              // when building combo urls
   *              root: '2.8.0r4/build/',
   *
   *              // the module definitions
   *              modules:  {
   *                  yui2_yde: {
   *                      path: "yahoo-dom-event/yahoo-dom-event.js"
   *                  },
   *                  yui2_anim: {
   *                      path: "animation/animation.js",
   *                      requires: ['yui2_yde']
   *                  }
   *              }
   *          }
   *      }
   *
   * @property groups
   * @type object
   */
  
  /**
   * The loader 'path' attribute to the loader itself.  This is combined
   * with the 'base' attribute to dynamically load the loader component
   * when boostrapping with the get utility alone.
   *
   * @property loaderPath
   * @type string
   * @default loader/loader-min.js
   */
  
  /**
   * Specifies whether or not YUI().use(...) will attempt to load CSS
   * resources at all.  Any truthy value will cause CSS dependencies
   * to load when fetching script.  The special value 'force' will
   * cause CSS dependencies to be loaded even if no script is needed.
   *
   * @property fetchCSS
   * @type boolean|string
   * @default true
   */
  
  /**
   * The default gallery version to build gallery module urls
   * @property gallery
   * @type string
   * @since 3.1.0
   */
  
  /**
   * The default YUI 2 version to build yui2 module urls.  This is for
   * intrinsic YUI 2 support via the 2in3 project.  Also see the '2in3'
   * config for pulling different revisions of the wrapped YUI 2
   * modules.
   * @since 3.1.0
   * @property yui2
   * @type string
   * @default 2.9.0
   */
  
  /**
   * The 2in3 project is a deployment of the various versions of YUI 2
   * deployed as first-class YUI 3 modules.  Eventually, the wrapper
   * for the modules will change (but the underlying YUI 2 code will
   * be the same), and you can select a particular version of
   * the wrapper modules via this config.
   * @since 3.1.0
   * @property 2in3
   * @type string
   * @default 4
   */
  
  /**
   * Alternative console log function for use in environments without
   * a supported native console.  The function is executed in the
   * YUI instance context.
   * @since 3.1.0
   * @property logFn
   * @type Function
   */
  
  /**
   * A callback to execute when Y.error is called.  It receives the
   * error message and an javascript error object if Y.error was
   * executed because a javascript error was caught.  The function
   * is executed in the YUI instance context. Returning `true` from this
   * function will stop the Error from being thrown.
   *
   * @since 3.2.0
   * @property errorFn
   * @type Function
   */
  
  /**
   * A callback to execute when the loader fails to load one or
   * more resource.  This could be because of a script load
   * failure.  It can also fail if a javascript module fails
   * to register itself, but only when the 'requireRegistration'
   * is true.  If this function is defined, the use() callback will
   * only be called when the loader succeeds, otherwise it always
   * executes unless there was a javascript error when attaching
   * a module.
   *
   * @since 3.3.0
   * @property loadErrorFn
   * @type Function
   */
  
  /**
   * When set to true, the YUI loader will expect that all modules
   * it is responsible for loading will be first-class YUI modules
   * that register themselves with the YUI global.  If this is
   * set to true, loader will fail if the module registration fails
   * to happen after the script is loaded.
   *
   * @since 3.3.0
   * @property requireRegistration
   * @type boolean
   * @default false
   */
  
  /**
   * Cache serviced use() requests.
   * @since 3.3.0
   * @property cacheUse
   * @type boolean
   * @default true
   * @deprecated no longer used
   */
  
  /**
   * Whether or not YUI should use native ES5 functionality when available for
   * features like `Y.Array.each()`, `Y.Object()`, etc. When `false`, YUI will
   * always use its own fallback implementations instead of relying on ES5
   * functionality, even when it's available.
   *
   * @property useNativeES5
   * @type Boolean
   * @default true
   * @since 3.5.0
   */
  
  /**
  Delay the `use` callback until a specific event has passed (`load`, `domready`, `contentready` or `available`)
  @property delayUntil
  @type String|Object
  @since 3.6.0
  @example
  
  You can use `load` or `domready` strings by default:
  
      YUI({
          delayUntil: 'domready'
      }, function(Y) {
          //This will not fire until 'domeready'
      });
  
  Or you can delay until a node is available (with `available` or `contentready`):
  
      YUI({
          delayUntil: {
              event: 'available',
              args: '#foo'
          }
      }, function(Y) {
          //This will not fire until '#foo' is 
          // available in the DOM
      });
      
  
  */
  YUI.add('yui-base', function(Y) {
  
  /*
   * YUI stub
   * @module yui
   * @submodule yui-base
   */
  /**
   * The YUI module contains the components required for building the YUI
   * seed file.  This includes the script loading mechanism, a simple queue,
   * and the core utilities for the library.
   * @module yui
   * @submodule yui-base
   */
  
  /**
   * Provides core language utilites and extensions used throughout YUI.
   *
   * @class Lang
   * @static
   */
  
  var L = Y.Lang || (Y.Lang = {}),
  
  STRING_PROTO = String.prototype,
  TOSTRING     = Object.prototype.toString,
  
  TYPES = {
      'undefined'        : 'undefined',
      'number'           : 'number',
      'boolean'          : 'boolean',
      'string'           : 'string',
      '[object Function]': 'function',
      '[object RegExp]'  : 'regexp',
      '[object Array]'   : 'array',
      '[object Date]'    : 'date',
      '[object Error]'   : 'error'
  },
  
  SUBREGEX        = /\{\s*([^|}]+?)\s*(?:\|([^}]*))?\s*\}/g,
  TRIMREGEX       = /^\s+|\s+$/g,
  NATIVE_FN_REGEX = /\{\s*\[(?:native code|function)\]\s*\}/i;
  
  // -- Protected Methods --------------------------------------------------------
  
  /**
  Returns `true` if the given function appears to be implemented in native code,
  `false` otherwise. Will always return `false` -- even in ES5-capable browsers --
  if the `useNativeES5` YUI config option is set to `false`.
  
  This isn't guaranteed to be 100% accurate and won't work for anything other than
  functions, but it can be useful for determining whether a function like
  `Array.prototype.forEach` is native or a JS shim provided by another library.
  
  There's a great article by @kangax discussing certain flaws with this technique:
  <http://perfectionkills.com/detecting-built-in-host-methods/>
  
  While his points are valid, it's still possible to benefit from this function
  as long as it's used carefully and sparingly, and in such a way that false
  negatives have minimal consequences. It's used internally to avoid using
  potentially broken non-native ES5 shims that have been added to the page by
  other libraries.
  
  @method _isNative
  @param {Function} fn Function to test.
  @return {Boolean} `true` if _fn_ appears to be native, `false` otherwise.
  @static
  @protected
  @since 3.5.0
  **/
  L._isNative = function (fn) {
      return !!(Y.config.useNativeES5 && fn && NATIVE_FN_REGEX.test(fn));
  };
  
  // -- Public Methods -----------------------------------------------------------
  
  /**
   * Determines whether or not the provided item is an array.
   *
   * Returns `false` for array-like collections such as the function `arguments`
   * collection or `HTMLElement` collections. Use `Y.Array.test()` if you want to
   * test for an array-like collection.
   *
   * @method isArray
   * @param o The object to test.
   * @return {boolean} true if o is an array.
   * @static
   */
  L.isArray = L._isNative(Array.isArray) ? Array.isArray : function (o) {
      return L.type(o) === 'array';
  };
  
  /**
   * Determines whether or not the provided item is a boolean.
   * @method isBoolean
   * @static
   * @param o The object to test.
   * @return {boolean} true if o is a boolean.
   */
  L.isBoolean = function(o) {
      return typeof o === 'boolean';
  };
  
  /**
   * Determines whether or not the supplied item is a date instance.
   * @method isDate
   * @static
   * @param o The object to test.
   * @return {boolean} true if o is a date.
   */
  L.isDate = function(o) {
      return L.type(o) === 'date' && o.toString() !== 'Invalid Date' && !isNaN(o);
  };
  
  /**
   * <p>
   * Determines whether or not the provided item is a function.
   * Note: Internet Explorer thinks certain functions are objects:
   * </p>
   *
   * <pre>
   * var obj = document.createElement("object");
   * Y.Lang.isFunction(obj.getAttribute) // reports false in IE
   * &nbsp;
   * var input = document.createElement("input"); // append to body
   * Y.Lang.isFunction(input.focus) // reports false in IE
   * </pre>
   *
   * <p>
   * You will have to implement additional tests if these functions
   * matter to you.
   * </p>
   *
   * @method isFunction
   * @static
   * @param o The object to test.
   * @return {boolean} true if o is a function.
   */
  L.isFunction = function(o) {
      return L.type(o) === 'function';
  };
  
  /**
   * Determines whether or not the provided item is null.
   * @method isNull
   * @static
   * @param o The object to test.
   * @return {boolean} true if o is null.
   */
  L.isNull = function(o) {
      return o === null;
  };
  
  /**
   * Determines whether or not the provided item is a legal number.
   * @method isNumber
   * @static
   * @param o The object to test.
   * @return {boolean} true if o is a number.
   */
  L.isNumber = function(o) {
      return typeof o === 'number' && isFinite(o);
  };
  
  /**
   * Determines whether or not the provided item is of type object
   * or function. Note that arrays are also objects, so
   * <code>Y.Lang.isObject([]) === true</code>.
   * @method isObject
   * @static
   * @param o The object to test.
   * @param failfn {boolean} fail if the input is a function.
   * @return {boolean} true if o is an object.
   * @see isPlainObject
   */
  L.isObject = function(o, failfn) {
      var t = typeof o;
      return (o && (t === 'object' ||
          (!failfn && (t === 'function' || L.isFunction(o))))) || false;
  };
  
  /**
   * Determines whether or not the provided item is a string.
   * @method isString
   * @static
   * @param o The object to test.
   * @return {boolean} true if o is a string.
   */
  L.isString = function(o) {
      return typeof o === 'string';
  };
  
  /**
   * Determines whether or not the provided item is undefined.
   * @method isUndefined
   * @static
   * @param o The object to test.
   * @return {boolean} true if o is undefined.
   */
  L.isUndefined = function(o) {
      return typeof o === 'undefined';
  };
  
  /**
   * A convenience method for detecting a legitimate non-null value.
   * Returns false for null/undefined/NaN, true for other values,
   * including 0/false/''
   * @method isValue
   * @static
   * @param o The item to test.
   * @return {boolean} true if it is not null/undefined/NaN || false.
   */
  L.isValue = function(o) {
      var t = L.type(o);
  
      switch (t) {
          case 'number':
              return isFinite(o);
  
          case 'null': // fallthru
          case 'undefined':
              return false;
  
          default:
              return !!t;
      }
  };
  
  /**
   * Returns the current time in milliseconds.
   *
   * @method now
   * @return {Number} Current time in milliseconds.
   * @static
   * @since 3.3.0
   */
  L.now = Date.now || function () {
      return new Date().getTime();
  };
  
  /**
   * Lightweight version of <code>Y.substitute</code>. Uses the same template
   * structure as <code>Y.substitute</code>, but doesn't support recursion,
   * auto-object coersion, or formats.
   * @method sub
   * @param {string} s String to be modified.
   * @param {object} o Object containing replacement values.
   * @return {string} the substitute result.
   * @static
   * @since 3.2.0
   */
  L.sub = function(s, o) {
      return s.replace ? s.replace(SUBREGEX, function (match, key) {
          return L.isUndefined(o[key]) ? match : o[key];
      }) : s;
  };
  
  /**
   * Returns a string without any leading or trailing whitespace.  If
   * the input is not a string, the input will be returned untouched.
   * @method trim
   * @static
   * @param s {string} the string to trim.
   * @return {string} the trimmed string.
   */
  L.trim = STRING_PROTO.trim ? function(s) {
      return s && s.trim ? s.trim() : s;
  } : function (s) {
      try {
          return s.replace(TRIMREGEX, '');
      } catch (e) {
          return s;
      }
  };
  
  /**
   * Returns a string without any leading whitespace.
   * @method trimLeft
   * @static
   * @param s {string} the string to trim.
   * @return {string} the trimmed string.
   */
  L.trimLeft = STRING_PROTO.trimLeft ? function (s) {
      return s.trimLeft();
  } : function (s) {
      return s.replace(/^\s+/, '');
  };
  
  /**
   * Returns a string without any trailing whitespace.
   * @method trimRight
   * @static
   * @param s {string} the string to trim.
   * @return {string} the trimmed string.
   */
  L.trimRight = STRING_PROTO.trimRight ? function (s) {
      return s.trimRight();
  } : function (s) {
      return s.replace(/\s+$/, '');
  };
  
  /**
  Returns one of the following strings, representing the type of the item passed
  in:
  
   * "array"
   * "boolean"
   * "date"
   * "error"
   * "function"
   * "null"
   * "number"
   * "object"
   * "regexp"
   * "string"
   * "undefined"
  
  Known issues:
  
   * `typeof HTMLElementCollection` returns function in Safari, but
      `Y.Lang.type()` reports "object", which could be a good thing --
      but it actually caused the logic in <code>Y.Lang.isObject</code> to fail.
  
  @method type
  @param o the item to test.
  @return {string} the detected type.
  @static
  **/
  L.type = function(o) {
      return TYPES[typeof o] || TYPES[TOSTRING.call(o)] || (o ? 'object' : 'null');
  };
  /**
  @module yui
  @submodule yui-base
  */
  
  var Lang   = Y.Lang,
      Native = Array.prototype,
  
      hasOwn = Object.prototype.hasOwnProperty;
  
  /**
  Provides utility methods for working with arrays. Additional array helpers can
  be found in the `collection` and `array-extras` modules.
  
  `Y.Array(thing)` returns a native array created from _thing_. Depending on
  _thing_'s type, one of the following will happen:
  
    * Arrays are returned unmodified unless a non-zero _startIndex_ is
      specified.
    * Array-like collections (see `Array.test()`) are converted to arrays.
    * For everything else, a new array is created with _thing_ as the sole
      item.
  
  Note: elements that are also collections, such as `<form>` and `<select>`
  elements, are not automatically converted to arrays. To force a conversion,
  pass `true` as the value of the _force_ parameter.
  
  @class Array
  @constructor
  @param {Any} thing The thing to arrayify.
  @param {Number} [startIndex=0] If non-zero and _thing_ is an array or array-like
    collection, a subset of items starting at the specified index will be
    returned.
  @param {Boolean} [force=false] If `true`, _thing_ will be treated as an
    array-like collection no matter what.
  @return {Array} A native array created from _thing_, according to the rules
    described above.
  **/
  function YArray(thing, startIndex, force) {
      var len, result;
  
      startIndex || (startIndex = 0);
  
      if (force || YArray.test(thing)) {
          // IE throws when trying to slice HTMLElement collections.
          try {
              return Native.slice.call(thing, startIndex);
          } catch (ex) {
              result = [];
  
              for (len = thing.length; startIndex < len; ++startIndex) {
                  result.push(thing[startIndex]);
              }
  
              return result;
          }
      }
  
      return [thing];
  }
  
  Y.Array = YArray;
  
  /**
  Dedupes an array of strings, returning an array that's guaranteed to contain
  only one copy of a given string.
  
  This method differs from `Array.unique()` in that it's optimized for use only
  with strings, whereas `unique` may be used with other types (but is slower).
  Using `dedupe()` with non-string values may result in unexpected behavior.
  
  @method dedupe
  @param {String[]} array Array of strings to dedupe.
  @return {Array} Deduped copy of _array_.
  @static
  @since 3.4.0
  **/
  YArray.dedupe = function (array) {
      var hash    = {},
          results = [],
          i, item, len;
  
      for (i = 0, len = array.length; i < len; ++i) {
          item = array[i];
  
          if (!hasOwn.call(hash, item)) {
              hash[item] = 1;
              results.push(item);
          }
      }
  
      return results;
  };
  
  /**
  Executes the supplied function on each item in the array. This method wraps
  the native ES5 `Array.forEach()` method if available.
  
  @method each
  @param {Array} array Array to iterate.
  @param {Function} fn Function to execute on each item in the array. The function
    will receive the following arguments:
      @param {Any} fn.item Current array item.
      @param {Number} fn.index Current array index.
      @param {Array} fn.array Array being iterated.
  @param {Object} [thisObj] `this` object to use when calling _fn_.
  @return {YUI} The YUI instance.
  @static
  **/
  YArray.each = YArray.forEach = Lang._isNative(Native.forEach) ? function (array, fn, thisObj) {
      Native.forEach.call(array || [], fn, thisObj || Y);
      return Y;
  } : function (array, fn, thisObj) {
      for (var i = 0, len = (array && array.length) || 0; i < len; ++i) {
          if (i in array) {
              fn.call(thisObj || Y, array[i], i, array);
          }
      }
  
      return Y;
  };
  
  /**
  Alias for `each()`.
  
  @method forEach
  @static
  **/
  
  /**
  Returns an object using the first array as keys and the second as values. If
  the second array is not provided, or if it doesn't contain the same number of
  values as the first array, then `true` will be used in place of the missing
  values.
  
  @example
  
      Y.Array.hash(['a', 'b', 'c'], ['foo', 'bar']);
      // => {a: 'foo', b: 'bar', c: true}
  
  @method hash
  @param {String[]} keys Array of strings to use as keys.
  @param {Array} [values] Array to use as values.
  @return {Object} Hash using the first array as keys and the second as values.
  @static
  **/
  YArray.hash = function (keys, values) {
      var hash = {},
          vlen = (values && values.length) || 0,
          i, len;
  
      for (i = 0, len = keys.length; i < len; ++i) {
          if (i in keys) {
              hash[keys[i]] = vlen > i && i in values ? values[i] : true;
          }
      }
  
      return hash;
  };
  
  /**
  Returns the index of the first item in the array that's equal (using a strict
  equality check) to the specified _value_, or `-1` if the value isn't found.
  
  This method wraps the native ES5 `Array.indexOf()` method if available.
  
  @method indexOf
  @param {Array} array Array to search.
  @param {Any} value Value to search for.
  @param {Number} [from=0] The index at which to begin the search.
  @return {Number} Index of the item strictly equal to _value_, or `-1` if not
      found.
  @static
  **/
  YArray.indexOf = Lang._isNative(Native.indexOf) ? function (array, value, from) {
      return Native.indexOf.call(array, value, from);
  } : function (array, value, from) {
      // http://es5.github.com/#x15.4.4.14
      var len = array.length;
  
      from = +from || 0;
      from = (from > 0 || -1) * Math.floor(Math.abs(from));
  
      if (from < 0) {
          from += len;
  
          if (from < 0) {
              from = 0;
          }
      }
  
      for (; from < len; ++from) {
          if (from in array && array[from] === value) {
              return from;
          }
      }
  
      return -1;
  };
  
  /**
  Numeric sort convenience function.
  
  The native `Array.prototype.sort()` function converts values to strings and
  sorts them in lexicographic order, which is unsuitable for sorting numeric
  values. Provide `Array.numericSort` as a custom sort function when you want
  to sort values in numeric order.
  
  @example
  
      [42, 23, 8, 16, 4, 15].sort(Y.Array.numericSort);
      // => [4, 8, 15, 16, 23, 42]
  
  @method numericSort
  @param {Number} a First value to compare.
  @param {Number} b Second value to compare.
  @return {Number} Difference between _a_ and _b_.
  @static
  **/
  YArray.numericSort = function (a, b) {
      return a - b;
  };
  
  /**
  Executes the supplied function on each item in the array. Returning a truthy
  value from the function will stop the processing of remaining items.
  
  @method some
  @param {Array} array Array to iterate over.
  @param {Function} fn Function to execute on each item. The function will receive
    the following arguments:
      @param {Any} fn.value Current array item.
      @param {Number} fn.index Current array index.
      @param {Array} fn.array Array being iterated over.
  @param {Object} [thisObj] `this` object to use when calling _fn_.
  @return {Boolean} `true` if the function returns a truthy value on any of the
    items in the array; `false` otherwise.
  @static
  **/
  YArray.some = Lang._isNative(Native.some) ? function (array, fn, thisObj) {
      return Native.some.call(array, fn, thisObj);
  } : function (array, fn, thisObj) {
      for (var i = 0, len = array.length; i < len; ++i) {
          if (i in array && fn.call(thisObj, array[i], i, array)) {
              return true;
          }
      }
  
      return false;
  };
  
  /**
  Evaluates _obj_ to determine if it's an array, an array-like collection, or
  something else. This is useful when working with the function `arguments`
  collection and `HTMLElement` collections.
  
  Note: This implementation doesn't consider elements that are also
  collections, such as `<form>` and `<select>`, to be array-like.
  
  @method test
  @param {Object} obj Object to test.
  @return {Number} A number indicating the results of the test:
  
    * 0: Neither an array nor an array-like collection.
    * 1: Real array.
    * 2: Array-like collection.
  
  @static
  **/
  YArray.test = function (obj) {
      var result = 0;
  
      if (Lang.isArray(obj)) {
          result = 1;
      } else if (Lang.isObject(obj)) {
          try {
              // indexed, but no tagName (element) or alert (window),
              // or functions without apply/call (Safari
              // HTMLElementCollection bug).
              if ('length' in obj && !obj.tagName && !obj.alert && !obj.apply) {
                  result = 2;
              }
          } catch (ex) {}
      }
  
      return result;
  };
  /**
   * The YUI module contains the components required for building the YUI
   * seed file.  This includes the script loading mechanism, a simple queue,
   * and the core utilities for the library.
   * @module yui
   * @submodule yui-base
   */
  
  /**
   * A simple FIFO queue.  Items are added to the Queue with add(1..n items) and
   * removed using next().
   *
   * @class Queue
   * @constructor
   * @param {MIXED} item* 0..n items to seed the queue.
   */
  function Queue() {
      this._init();
      this.add.apply(this, arguments);
  }
  
  Queue.prototype = {
      /**
       * Initialize the queue
       *
       * @method _init
       * @protected
       */
      _init: function() {
          /**
           * The collection of enqueued items
           *
           * @property _q
           * @type Array
           * @protected
           */
          this._q = [];
      },
  
      /**
       * Get the next item in the queue. FIFO support
       *
       * @method next
       * @return {MIXED} the next item in the queue.
       */
      next: function() {
          return this._q.shift();
      },
  
      /**
       * Get the last in the queue. LIFO support.
       *
       * @method last
       * @return {MIXED} the last item in the queue.
       */
      last: function() {
          return this._q.pop();
      },
  
      /**
       * Add 0..n items to the end of the queue.
       *
       * @method add
       * @param {MIXED} item* 0..n items.
       * @return {object} this queue.
       */
      add: function() {
          this._q.push.apply(this._q, arguments);
  
          return this;
      },
  
      /**
       * Returns the current number of queued items.
       *
       * @method size
       * @return {Number} The size.
       */
      size: function() {
          return this._q.length;
      }
  };
  
  Y.Queue = Queue;
  
  YUI.Env._loaderQueue = YUI.Env._loaderQueue || new Queue();
  
  /**
  The YUI module contains the components required for building the YUI seed file.
  This includes the script loading mechanism, a simple queue, and the core
  utilities for the library.
  
  @module yui
  @submodule yui-base
  **/
  
  var CACHED_DELIMITER = '__',
  
      hasOwn   = Object.prototype.hasOwnProperty,
      isObject = Y.Lang.isObject;
  
  /**
  Returns a wrapper for a function which caches the return value of that function,
  keyed off of the combined string representation of the argument values provided
  when the wrapper is called.
  
  Calling this function again with the same arguments will return the cached value
  rather than executing the wrapped function.
  
  Note that since the cache is keyed off of the string representation of arguments
  passed to the wrapper function, arguments that aren't strings and don't provide
  a meaningful `toString()` method may result in unexpected caching behavior. For
  example, the objects `{}` and `{foo: 'bar'}` would both be converted to the
  string `[object Object]` when used as a cache key.
  
  @method cached
  @param {Function} source The function to memoize.
  @param {Object} [cache={}] Object in which to store cached values. You may seed
    this object with pre-existing cached values if desired.
  @param {any} [refetch] If supplied, this value is compared with the cached value
    using a `==` comparison. If the values are equal, the wrapped function is
    executed again even though a cached value exists.
  @return {Function} Wrapped function.
  @for YUI
  **/
  Y.cached = function (source, cache, refetch) {
      cache || (cache = {});
  
      return function (arg) {
          var key = arguments.length > 1 ?
                  Array.prototype.join.call(arguments, CACHED_DELIMITER) :
                  String(arg);
  
          if (!(key in cache) || (refetch && cache[key] == refetch)) {
              cache[key] = source.apply(source, arguments);
          }
  
          return cache[key];
      };
  };
  
  /**
  Returns the `location` object from the window/frame in which this YUI instance
  operates, or `undefined` when executing in a non-browser environment
  (e.g. Node.js).
  
  It is _not_ recommended to hold references to the `window.location` object
  outside of the scope of a function in which its properties are being accessed or
  its methods are being called. This is because of a nasty bug/issue that exists
  in both Safari and MobileSafari browsers:
  [WebKit Bug 34679](https://bugs.webkit.org/show_bug.cgi?id=34679).
  
  @method getLocation
  @return {location} The `location` object from the window/frame in which this YUI
      instance operates.
  @since 3.5.0
  **/
  Y.getLocation = function () {
      // It is safer to look this up every time because yui-base is attached to a
      // YUI instance before a user's config is applied; i.e. `Y.config.win` does
      // not point the correct window object when this file is loaded.
      var win = Y.config.win;
  
      // It is not safe to hold a reference to the `location` object outside the
      // scope in which it is being used. The WebKit engine used in Safari and
      // MobileSafari will "disconnect" the `location` object from the `window`
      // when a page is restored from back/forward history cache.
      return win && win.location;
  };
  
  /**
  Returns a new object containing all of the properties of all the supplied
  objects. The properties from later objects will overwrite those in earlier
  objects.
  
  Passing in a single object will create a shallow copy of it. For a deep copy,
  use `clone()`.
  
  @method merge
  @param {Object} objects* One or more objects to merge.
  @return {Object} A new merged object.
  **/
  Y.merge = function () {
      var args   = arguments,
          i      = 0,
          len    = args.length,
          result = {};
  
      for (; i < len; ++i) {
          Y.mix(result, args[i], true);
      }
  
      return result;
  };
  
  /**
  Mixes _supplier_'s properties into _receiver_.
  
  Properties on _receiver_ or _receiver_'s prototype will not be overwritten or
  shadowed unless the _overwrite_ parameter is `true`, and will not be merged
  unless the _merge_ parameter is `true`.
  
  In the default mode (0), only properties the supplier owns are copied (prototype
  properties are not copied). The following copying modes are available:
  
    * `0`: _Default_. Object to object.
    * `1`: Prototype to prototype.
    * `2`: Prototype to prototype and object to object.
    * `3`: Prototype to object.
    * `4`: Object to prototype.
  
  @method mix
  @param {Function|Object} receiver The object or function to receive the mixed
    properties.
  @param {Function|Object} supplier The object or function supplying the
    properties to be mixed.
  @param {Boolean} [overwrite=false] If `true`, properties that already exist
    on the receiver will be overwritten with properties from the supplier.
  @param {String[]} [whitelist] An array of property names to copy. If
    specified, only the whitelisted properties will be copied, and all others
    will be ignored.
  @param {Number} [mode=0] Mix mode to use. See above for available modes.
  @param {Boolean} [merge=false] If `true`, objects and arrays that already
    exist on the receiver will have the corresponding object/array from the
    supplier merged into them, rather than being skipped or overwritten. When
    both _overwrite_ and _merge_ are `true`, _merge_ takes precedence.
  @return {Function|Object|YUI} The receiver, or the YUI instance if the
    specified receiver is falsy.
  **/
  Y.mix = function(receiver, supplier, overwrite, whitelist, mode, merge) {
      var alwaysOverwrite, exists, from, i, key, len, to;
  
      // If no supplier is given, we return the receiver. If no receiver is given,
      // we return Y. Returning Y doesn't make much sense to me, but it's
      // grandfathered in for backcompat reasons.
      if (!receiver || !supplier) {
          return receiver || Y;
      }
  
      if (mode) {
          // In mode 2 (prototype to prototype and object to object), we recurse
          // once to do the proto to proto mix. The object to object mix will be
          // handled later on.
          if (mode === 2) {
              Y.mix(receiver.prototype, supplier.prototype, overwrite,
                      whitelist, 0, merge);
          }
  
          // Depending on which mode is specified, we may be copying from or to
          // the prototypes of the supplier and receiver.
          from = mode === 1 || mode === 3 ? supplier.prototype : supplier;
          to   = mode === 1 || mode === 4 ? receiver.prototype : receiver;
  
          // If either the supplier or receiver doesn't actually have a
          // prototype property, then we could end up with an undefined `from`
          // or `to`. If that happens, we abort and return the receiver.
          if (!from || !to) {
              return receiver;
          }
      } else {
          from = supplier;
          to   = receiver;
      }
  
      // If `overwrite` is truthy and `merge` is falsy, then we can skip a
      // property existence check on each iteration and save some time.
      alwaysOverwrite = overwrite && !merge;
  
      if (whitelist) {
          for (i = 0, len = whitelist.length; i < len; ++i) {
              key = whitelist[i];
  
              // We call `Object.prototype.hasOwnProperty` instead of calling
              // `hasOwnProperty` on the object itself, since the object's
              // `hasOwnProperty` method may have been overridden or removed.
              // Also, some native objects don't implement a `hasOwnProperty`
              // method.
              if (!hasOwn.call(from, key)) {
                  continue;
              }
  
              // The `key in to` check here is (sadly) intentional for backwards
              // compatibility reasons. It prevents undesired shadowing of
              // prototype members on `to`.
              exists = alwaysOverwrite ? false : key in to;
  
              if (merge && exists && isObject(to[key], true)
                      && isObject(from[key], true)) {
                  // If we're in merge mode, and the key is present on both
                  // objects, and the value on both objects is either an object or
                  // an array (but not a function), then we recurse to merge the
                  // `from` value into the `to` value instead of overwriting it.
                  //
                  // Note: It's intentional that the whitelist isn't passed to the
                  // recursive call here. This is legacy behavior that lots of
                  // code still depends on.
                  Y.mix(to[key], from[key], overwrite, null, 0, merge);
              } else if (overwrite || !exists) {
                  // We're not in merge mode, so we'll only copy the `from` value
                  // to the `to` value if we're in overwrite mode or if the
                  // current key doesn't exist on the `to` object.
                  to[key] = from[key];
              }
          }
      } else {
          for (key in from) {
              // The code duplication here is for runtime performance reasons.
              // Combining whitelist and non-whitelist operations into a single
              // loop or breaking the shared logic out into a function both result
              // in worse performance, and Y.mix is critical enough that the byte
              // tradeoff is worth it.
              if (!hasOwn.call(from, key)) {
                  continue;
              }
  
              // The `key in to` check here is (sadly) intentional for backwards
              // compatibility reasons. It prevents undesired shadowing of
              // prototype members on `to`.
              exists = alwaysOverwrite ? false : key in to;
  
              if (merge && exists && isObject(to[key], true)
                      && isObject(from[key], true)) {
                  Y.mix(to[key], from[key], overwrite, null, 0, merge);
              } else if (overwrite || !exists) {
                  to[key] = from[key];
              }
          }
  
          // If this is an IE browser with the JScript enumeration bug, force
          // enumeration of the buggy properties by making a recursive call with
          // the buggy properties as the whitelist.
          if (Y.Object._hasEnumBug) {
              Y.mix(to, from, overwrite, Y.Object._forceEnum, mode, merge);
          }
      }
  
      return receiver;
  };
  /**
   * The YUI module contains the components required for building the YUI
   * seed file.  This includes the script loading mechanism, a simple queue,
   * and the core utilities for the library.
   * @module yui
   * @submodule yui-base
   */
  
  /**
   * Adds utilities to the YUI instance for working with objects.
   *
   * @class Object
   */
  
  var Lang   = Y.Lang,
      hasOwn = Object.prototype.hasOwnProperty,
  
      UNDEFINED, // <-- Note the comma. We're still declaring vars.
  
  /**
   * Returns a new object that uses _obj_ as its prototype. This method wraps the
   * native ES5 `Object.create()` method if available, but doesn't currently
   * pass through `Object.create()`'s second argument (properties) in order to
   * ensure compatibility with older browsers.
   *
   * @method ()
   * @param {Object} obj Prototype object.
   * @return {Object} New object using _obj_ as its prototype.
   * @static
   */
  O = Y.Object = Lang._isNative(Object.create) ? function (obj) {
      // We currently wrap the native Object.create instead of simply aliasing it
      // to ensure consistency with our fallback shim, which currently doesn't
      // support Object.create()'s second argument (properties). Once we have a
      // safe fallback for the properties arg, we can stop wrapping
      // Object.create().
      return Object.create(obj);
  } : (function () {
      // Reusable constructor function for the Object.create() shim.
      function F() {}
  
      // The actual shim.
      return function (obj) {
          F.prototype = obj;
          return new F();
      };
  }()),
  
  /**
   * Property names that IE doesn't enumerate in for..in loops, even when they
   * should be enumerable. When `_hasEnumBug` is `true`, it's necessary to
   * manually enumerate these properties.
   *
   * @property _forceEnum
   * @type String[]
   * @protected
   * @static
   */
  forceEnum = O._forceEnum = [
      'hasOwnProperty',
      'isPrototypeOf',
      'propertyIsEnumerable',
      'toString',
      'toLocaleString',
      'valueOf'
  ],
  
  /**
   * `true` if this browser has the JScript enumeration bug that prevents
   * enumeration of the properties named in the `_forceEnum` array, `false`
   * otherwise.
   *
   * See:
   *   - <https://developer.mozilla.org/en/ECMAScript_DontEnum_attribute#JScript_DontEnum_Bug>
   *   - <http://whattheheadsaid.com/2010/10/a-safer-object-keys-compatibility-implementation>
   *
   * @property _hasEnumBug
   * @type Boolean
   * @protected
   * @static
   */
  hasEnumBug = O._hasEnumBug = !{valueOf: 0}.propertyIsEnumerable('valueOf'),
  
  /**
   * `true` if this browser incorrectly considers the `prototype` property of
   * functions to be enumerable. Currently known to affect Opera 11.50.
   *
   * @property _hasProtoEnumBug
   * @type Boolean
   * @protected
   * @static
   */
  hasProtoEnumBug = O._hasProtoEnumBug = (function () {}).propertyIsEnumerable('prototype'),
  
  /**
   * Returns `true` if _key_ exists on _obj_, `false` if _key_ doesn't exist or
   * exists only on _obj_'s prototype. This is essentially a safer version of
   * `obj.hasOwnProperty()`.
   *
   * @method owns
   * @param {Object} obj Object to test.
   * @param {String} key Property name to look for.
   * @return {Boolean} `true` if _key_ exists on _obj_, `false` otherwise.
   * @static
   */
  owns = O.owns = function (obj, key) {
      return !!obj && hasOwn.call(obj, key);
  }; // <-- End of var declarations.
  
  /**
   * Alias for `owns()`.
   *
   * @method hasKey
   * @param {Object} obj Object to test.
   * @param {String} key Property name to look for.
   * @return {Boolean} `true` if _key_ exists on _obj_, `false` otherwise.
   * @static
   */
  O.hasKey = owns;
  
  /**
   * Returns an array containing the object's enumerable keys. Does not include
   * prototype keys or non-enumerable keys.
   *
   * Note that keys are returned in enumeration order (that is, in the same order
   * that they would be enumerated by a `for-in` loop), which may not be the same
   * as the order in which they were defined.
   *
   * This method is an alias for the native ES5 `Object.keys()` method if
   * available.
   *
   * @example
   *
   *     Y.Object.keys({a: 'foo', b: 'bar', c: 'baz'});
   *     // => ['a', 'b', 'c']
   *
   * @method keys
   * @param {Object} obj An object.
   * @return {String[]} Array of keys.
   * @static
   */
  O.keys = Lang._isNative(Object.keys) ? Object.keys : function (obj) {
      if (!Lang.isObject(obj)) {
          throw new TypeError('Object.keys called on a non-object');
      }
  
      var keys = [],
          i, key, len;
  
      if (hasProtoEnumBug && typeof obj === 'function') {
          for (key in obj) {
              if (owns(obj, key) && key !== 'prototype') {
                  keys.push(key);
              }
          }
      } else {
          for (key in obj) {
              if (owns(obj, key)) {
                  keys.push(key);
              }
          }
      }
  
      if (hasEnumBug) {
          for (i = 0, len = forceEnum.length; i < len; ++i) {
              key = forceEnum[i];
  
              if (owns(obj, key)) {
                  keys.push(key);
              }
          }
      }
  
      return keys;
  };
  
  /**
   * Returns an array containing the values of the object's enumerable keys.
   *
   * Note that values are returned in enumeration order (that is, in the same
   * order that they would be enumerated by a `for-in` loop), which may not be the
   * same as the order in which they were defined.
   *
   * @example
   *
   *     Y.Object.values({a: 'foo', b: 'bar', c: 'baz'});
   *     // => ['foo', 'bar', 'baz']
   *
   * @method values
   * @param {Object} obj An object.
   * @return {Array} Array of values.
   * @static
   */
  O.values = function (obj) {
      var keys   = O.keys(obj),
          i      = 0,
          len    = keys.length,
          values = [];
  
      for (; i < len; ++i) {
          values.push(obj[keys[i]]);
      }
  
      return values;
  };
  
  /**
   * Returns the number of enumerable keys owned by an object.
   *
   * @method size
   * @param {Object} obj An object.
   * @return {Number} The object's size.
   * @static
   */
  O.size = function (obj) {
      try {
          return O.keys(obj).length;
      } catch (ex) {
          return 0; // Legacy behavior for non-objects.
      }
  };
  
  /**
   * Returns `true` if the object owns an enumerable property with the specified
   * value.
   *
   * @method hasValue
   * @param {Object} obj An object.
   * @param {any} value The value to search for.
   * @return {Boolean} `true` if _obj_ contains _value_, `false` otherwise.
   * @static
   */
  O.hasValue = function (obj, value) {
      return Y.Array.indexOf(O.values(obj), value) > -1;
  };
  
  /**
   * Executes a function on each enumerable property in _obj_. The function
   * receives the value, the key, and the object itself as parameters (in that
   * order).
   *
   * By default, only properties owned by _obj_ are enumerated. To include
   * prototype properties, set the _proto_ parameter to `true`.
   *
   * @method each
   * @param {Object} obj Object to enumerate.
   * @param {Function} fn Function to execute on each enumerable property.
   *   @param {mixed} fn.value Value of the current property.
   *   @param {String} fn.key Key of the current property.
   *   @param {Object} fn.obj Object being enumerated.
   * @param {Object} [thisObj] `this` object to use when calling _fn_.
   * @param {Boolean} [proto=false] Include prototype properties.
   * @return {YUI} the YUI instance.
   * @chainable
   * @static
   */
  O.each = function (obj, fn, thisObj, proto) {
      var key;
  
      for (key in obj) {
          if (proto || owns(obj, key)) {
              fn.call(thisObj || Y, obj[key], key, obj);
          }
      }
  
      return Y;
  };
  
  /**
   * Executes a function on each enumerable property in _obj_, but halts if the
   * function returns a truthy value. The function receives the value, the key,
   * and the object itself as paramters (in that order).
   *
   * By default, only properties owned by _obj_ are enumerated. To include
   * prototype properties, set the _proto_ parameter to `true`.
   *
   * @method some
   * @param {Object} obj Object to enumerate.
   * @param {Function} fn Function to execute on each enumerable property.
   *   @param {mixed} fn.value Value of the current property.
   *   @param {String} fn.key Key of the current property.
   *   @param {Object} fn.obj Object being enumerated.
   * @param {Object} [thisObj] `this` object to use when calling _fn_.
   * @param {Boolean} [proto=false] Include prototype properties.
   * @return {Boolean} `true` if any execution of _fn_ returns a truthy value,
   *   `false` otherwise.
   * @static
   */
  O.some = function (obj, fn, thisObj, proto) {
      var key;
  
      for (key in obj) {
          if (proto || owns(obj, key)) {
              if (fn.call(thisObj || Y, obj[key], key, obj)) {
                  return true;
              }
          }
      }
  
      return false;
  };
  
  /**
   * Retrieves the sub value at the provided path,
   * from the value object provided.
   *
   * @method getValue
   * @static
   * @param o The object from which to extract the property value.
   * @param path {Array} A path array, specifying the object traversal path
   * from which to obtain the sub value.
   * @return {Any} The value stored in the path, undefined if not found,
   * undefined if the source is not an object.  Returns the source object
   * if an empty path is provided.
   */
  O.getValue = function(o, path) {
      if (!Lang.isObject(o)) {
          return UNDEFINED;
      }
  
      var i,
          p = Y.Array(path),
          l = p.length;
  
      for (i = 0; o !== UNDEFINED && i < l; i++) {
          o = o[p[i]];
      }
  
      return o;
  };
  
  /**
   * Sets the sub-attribute value at the provided path on the
   * value object.  Returns the modified value object, or
   * undefined if the path is invalid.
   *
   * @method setValue
   * @static
   * @param o             The object on which to set the sub value.
   * @param path {Array}  A path array, specifying the object traversal path
   *                      at which to set the sub value.
   * @param val {Any}     The new value for the sub-attribute.
   * @return {Object}     The modified object, with the new sub value set, or
   *                      undefined, if the path was invalid.
   */
  O.setValue = function(o, path, val) {
      var i,
          p = Y.Array(path),
          leafIdx = p.length - 1,
          ref = o;
  
      if (leafIdx >= 0) {
          for (i = 0; ref !== UNDEFINED && i < leafIdx; i++) {
              ref = ref[p[i]];
          }
  
          if (ref !== UNDEFINED) {
              ref[p[i]] = val;
          } else {
              return UNDEFINED;
          }
      }
  
      return o;
  };
  
  /**
   * Returns `true` if the object has no enumerable properties of its own.
   *
   * @method isEmpty
   * @param {Object} obj An object.
   * @return {Boolean} `true` if the object is empty.
   * @static
   * @since 3.2.0
   */
  O.isEmpty = function (obj) {
      return !O.keys(Object(obj)).length;
  };
  /**
   * The YUI module contains the components required for building the YUI seed
   * file.  This includes the script loading mechanism, a simple queue, and the
   * core utilities for the library.
   * @module yui
   * @submodule yui-base
   */
  
  /**
   * YUI user agent detection.
   * Do not fork for a browser if it can be avoided.  Use feature detection when
   * you can.  Use the user agent as a last resort.  For all fields listed
   * as @type float, UA stores a version number for the browser engine,
   * 0 otherwise.  This value may or may not map to the version number of
   * the browser using the engine.  The value is presented as a float so
   * that it can easily be used for boolean evaluation as well as for
   * looking for a particular range of versions.  Because of this,
   * some of the granularity of the version info may be lost.  The fields that
   * are @type string default to null.  The API docs list the values that
   * these fields can have.
   * @class UA
   * @static
   */
  
  /**
  * Static method on `YUI.Env` for parsing a UA string.  Called at instantiation
  * to populate `Y.UA`.
  *
  * @static
  * @method parseUA
  * @param {String} [subUA=navigator.userAgent] UA string to parse
  * @return {Object} The Y.UA object
  */
  YUI.Env.parseUA = function(subUA) {
  
      var numberify = function(s) {
              var c = 0;
              return parseFloat(s.replace(/\./g, function() {
                  return (c++ == 1) ? '' : '.';
              }));
          },
  
          win = Y.config.win,
  
          nav = win && win.navigator,
  
          o = {
  
          /**
           * Internet Explorer version number or 0.  Example: 6
           * @property ie
           * @type float
           * @static
           */
          ie: 0,
  
          /**
           * Opera version number or 0.  Example: 9.2
           * @property opera
           * @type float
           * @static
           */
          opera: 0,
  
          /**
           * Gecko engine revision number.  Will evaluate to 1 if Gecko
           * is detected but the revision could not be found. Other browsers
           * will be 0.  Example: 1.8
           * <pre>
           * Firefox 1.0.0.4: 1.7.8   <-- Reports 1.7
           * Firefox 1.5.0.9: 1.8.0.9 <-- 1.8
           * Firefox 2.0.0.3: 1.8.1.3 <-- 1.81
           * Firefox 3.0   <-- 1.9
           * Firefox 3.5   <-- 1.91
           * </pre>
           * @property gecko
           * @type float
           * @static
           */
          gecko: 0,
  
          /**
           * AppleWebKit version.  KHTML browsers that are not WebKit browsers
           * will evaluate to 1, other browsers 0.  Example: 418.9
           * <pre>
           * Safari 1.3.2 (312.6): 312.8.1 <-- Reports 312.8 -- currently the
           *                                   latest available for Mac OSX 10.3.
           * Safari 2.0.2:         416     <-- hasOwnProperty introduced
           * Safari 2.0.4:         418     <-- preventDefault fixed
           * Safari 2.0.4 (419.3): 418.9.1 <-- One version of Safari may run
           *                                   different versions of webkit
           * Safari 2.0.4 (419.3): 419     <-- Tiger installations that have been
           *                                   updated, but not updated
           *                                   to the latest patch.
           * Webkit 212 nightly:   522+    <-- Safari 3.0 precursor (with native
           * SVG and many major issues fixed).
           * Safari 3.0.4 (523.12) 523.12  <-- First Tiger release - automatic
           * update from 2.x via the 10.4.11 OS patch.
           * Webkit nightly 1/2008:525+    <-- Supports DOMContentLoaded event.
           *                                   yahoo.com user agent hack removed.
           * </pre>
           * http://en.wikipedia.org/wiki/Safari_version_history
           * @property webkit
           * @type float
           * @static
           */
          webkit: 0,
  
          /**
           * Safari will be detected as webkit, but this property will also
           * be populated with the Safari version number
           * @property safari
           * @type float
           * @static
           */
          safari: 0,
  
          /**
           * Chrome will be detected as webkit, but this property will also
           * be populated with the Chrome version number
           * @property chrome
           * @type float
           * @static
           */
          chrome: 0,
  
          /**
           * The mobile property will be set to a string containing any relevant
           * user agent information when a modern mobile browser is detected.
           * Currently limited to Safari on the iPhone/iPod Touch, Nokia N-series
           * devices with the WebKit-based browser, and Opera Mini.
           * @property mobile
           * @type string
           * @default null
           * @static
           */
          mobile: null,
  
          /**
           * Adobe AIR version number or 0.  Only populated if webkit is detected.
           * Example: 1.0
           * @property air
           * @type float
           */
          air: 0,
          /**
           * PhantomJS version number or 0.  Only populated if webkit is detected.
           * Example: 1.0
           * @property phantomjs
           * @type float
           */
          phantomjs: 0,
          /**
           * Adobe AIR version number or 0.  Only populated if webkit is detected.
           * Example: 1.0
           * @property air
           * @type float
           */
          air: 0,
          /**
           * Detects Apple iPad's OS version
           * @property ipad
           * @type float
           * @static
           */
          ipad: 0,
          /**
           * Detects Apple iPhone's OS version
           * @property iphone
           * @type float
           * @static
           */
          iphone: 0,
          /**
           * Detects Apples iPod's OS version
           * @property ipod
           * @type float
           * @static
           */
          ipod: 0,
          /**
           * General truthy check for iPad, iPhone or iPod
           * @property ios
           * @type Boolean
           * @default null
           * @static
           */
          ios: null,
          /**
           * Detects Googles Android OS version
           * @property android
           * @type float
           * @static
           */
          android: 0,
          /**
           * Detects Kindle Silk
           * @property silk
           * @type float
           * @static
           */
          silk: 0,
          /**
           * Detects Kindle Silk Acceleration
           * @property accel
           * @type Boolean
           * @static
           */
          accel: false,
          /**
           * Detects Palms WebOS version
           * @property webos
           * @type float
           * @static
           */
          webos: 0,
  
          /**
           * Google Caja version number or 0.
           * @property caja
           * @type float
           */
          caja: nav && nav.cajaVersion,
  
          /**
           * Set to true if the page appears to be in SSL
           * @property secure
           * @type boolean
           * @static
           */
          secure: false,
  
          /**
           * The operating system.  Currently only detecting windows or macintosh
           * @property os
           * @type string
           * @default null
           * @static
           */
          os: null,
  
          /**
           * The Nodejs Version
           * @property nodejs
           * @type float
           * @default 0
           * @static
           */
          nodejs: 0
      },
  
      ua = subUA || nav && nav.userAgent,
  
      loc = win && win.location,
  
      href = loc && loc.href,
  
      m;
  
      /**
      * The User Agent string that was parsed
      * @property userAgent
      * @type String
      * @static
      */
      o.userAgent = ua;
  
  
      o.secure = href && (href.toLowerCase().indexOf('https') === 0);
  
      if (ua) {
  
          if ((/windows|win32/i).test(ua)) {
              o.os = 'windows';
          } else if ((/macintosh|mac_powerpc/i).test(ua)) {
              o.os = 'macintosh';
          } else if ((/android/i).test(ua)) {
              o.os = 'android';
          } else if ((/symbos/i).test(ua)) {
              o.os = 'symbos';
          } else if ((/linux/i).test(ua)) {
              o.os = 'linux';
          } else if ((/rhino/i).test(ua)) {
              o.os = 'rhino';
          }
  
          // Modern KHTML browsers should qualify as Safari X-Grade
          if ((/KHTML/).test(ua)) {
              o.webkit = 1;
          }
          if ((/IEMobile|XBLWP7/).test(ua)) {
              o.mobile = 'windows';
          }
          if ((/Fennec/).test(ua)) {
              o.mobile = 'gecko';
          }
          // Modern WebKit browsers are at least X-Grade
          m = ua.match(/AppleWebKit\/([^\s]*)/);
          if (m && m[1]) {
              o.webkit = numberify(m[1]);
              o.safari = o.webkit;
              
              if (/PhantomJS/.test(ua)) {
                  m = ua.match(/PhantomJS\/([^\s]*)/);
                  if (m && m[1]) {
                      o.phantomjs = numberify(m[1]);
                  }
              }
  
              // Mobile browser check
              if (/ Mobile\//.test(ua) || (/iPad|iPod|iPhone/).test(ua)) {
                  o.mobile = 'Apple'; // iPhone or iPod Touch
  
                  m = ua.match(/OS ([^\s]*)/);
                  if (m && m[1]) {
                      m = numberify(m[1].replace('_', '.'));
                  }
                  o.ios = m;
                  o.os = 'ios';
                  o.ipad = o.ipod = o.iphone = 0;
  
                  m = ua.match(/iPad|iPod|iPhone/);
                  if (m && m[0]) {
                      o[m[0].toLowerCase()] = o.ios;
                  }
              } else {
                  m = ua.match(/NokiaN[^\/]*|webOS\/\d\.\d/);
                  if (m) {
                      // Nokia N-series, webOS, ex: NokiaN95
                      o.mobile = m[0];
                  }
                  if (/webOS/.test(ua)) {
                      o.mobile = 'WebOS';
                      m = ua.match(/webOS\/([^\s]*);/);
                      if (m && m[1]) {
                          o.webos = numberify(m[1]);
                      }
                  }
                  if (/ Android/.test(ua)) {
                      if (/Mobile/.test(ua)) {
                          o.mobile = 'Android';
                      }
                      m = ua.match(/Android ([^\s]*);/);
                      if (m && m[1]) {
                          o.android = numberify(m[1]);
                      }
  
                  }
                  if (/Silk/.test(ua)) {
                      m = ua.match(/Silk\/([^\s]*)\)/);
                      if (m && m[1]) {
                          o.silk = numberify(m[1]);
                      }
                      if (!o.android) {
                          o.android = 2.34; //Hack for desktop mode in Kindle
                          o.os = 'Android';
                      }
                      if (/Accelerated=true/.test(ua)) {
                          o.accel = true;
                      }
                  }
              }
  
              m = ua.match(/(Chrome|CrMo|CriOS)\/([^\s]*)/);
              if (m && m[1] && m[2]) {
                  o.chrome = numberify(m[2]); // Chrome
                  o.safari = 0; //Reset safari back to 0
                  if (m[1] === 'CrMo') {
                      o.mobile = 'chrome';
                  }
              } else {
                  m = ua.match(/AdobeAIR\/([^\s]*)/);
                  if (m) {
                      o.air = m[0]; // Adobe AIR 1.0 or better
                  }
              }
          }
  
          if (!o.webkit) { // not webkit
  // @todo check Opera/8.01 (J2ME/MIDP; Opera Mini/2.0.4509/1316; fi; U; ssr)
              if (/Opera/.test(ua)) {
                  m = ua.match(/Opera[\s\/]([^\s]*)/);
                  if (m && m[1]) {
                      o.opera = numberify(m[1]);
                  }
                  m = ua.match(/Version\/([^\s]*)/);
                  if (m && m[1]) {
                      o.opera = numberify(m[1]); // opera 10+
                  }
  
                  if (/Opera Mobi/.test(ua)) {
                      o.mobile = 'opera';
                      m = ua.replace('Opera Mobi', '').match(/Opera ([^\s]*)/);
                      if (m && m[1]) {
                          o.opera = numberify(m[1]);
                      }
                  }
                  m = ua.match(/Opera Mini[^;]*/);
  
                  if (m) {
                      o.mobile = m[0]; // ex: Opera Mini/2.0.4509/1316
                  }
              } else { // not opera or webkit
                  m = ua.match(/MSIE\s([^;]*)/);
                  if (m && m[1]) {
                      o.ie = numberify(m[1]);
                  } else { // not opera, webkit, or ie
                      m = ua.match(/Gecko\/([^\s]*)/);
                      if (m) {
                          o.gecko = 1; // Gecko detected, look for revision
                          m = ua.match(/rv:([^\s\)]*)/);
                          if (m && m[1]) {
                              o.gecko = numberify(m[1]);
                          }
                      }
                  }
              }
          }
      }
  
      //It was a parsed UA, do not assign the global value.
      if (!subUA) {
  
          if (typeof process == 'object') {
  
              if (process.versions && process.versions.node) {
                  //NodeJS
                  o.os = process.platform;
                  o.nodejs = numberify(process.versions.node);
              }
          }
  
          YUI.Env.UA = o;
  
      }
  
      return o;
  };
  
  
  Y.UA = YUI.Env.UA || YUI.Env.parseUA();
  
  /**
  Performs a simple comparison between two version numbers, accounting for
  standard versioning logic such as the fact that "535.8" is a lower version than
  "535.24", even though a simple numerical comparison would indicate that it's
  greater. Also accounts for cases such as "1.1" vs. "1.1.0", which are
  considered equivalent.
  
  Returns -1 if version _a_ is lower than version _b_, 0 if they're equivalent,
  1 if _a_ is higher than _b_.
  
  Versions may be numbers or strings containing numbers and dots. For example,
  both `535` and `"535.8.10"` are acceptable. A version string containing
  non-numeric characters, like `"535.8.beta"`, may produce unexpected results.
  
  @method compareVersions
  @param {Number|String} a First version number to compare.
  @param {Number|String} b Second version number to compare.
  @return -1 if _a_ is lower than _b_, 0 if they're equivalent, 1 if _a_ is
      higher than _b_.
  **/
  Y.UA.compareVersions = function (a, b) {
      var aPart, aParts, bPart, bParts, i, len;
  
      if (a === b) {
          return 0;
      }
  
      aParts = (a + '').split('.');
      bParts = (b + '').split('.');
  
      for (i = 0, len = Math.max(aParts.length, bParts.length); i < len; ++i) {
          aPart = parseInt(aParts[i], 10);
          bPart = parseInt(bParts[i], 10);
  
          isNaN(aPart) && (aPart = 0);
          isNaN(bPart) && (bPart = 0);
  
          if (aPart < bPart) {
              return -1;
          }
  
          if (aPart > bPart) {
              return 1;
          }
      }
  
      return 0;
  };
  YUI.Env.aliases = {
      "anim": ["anim-base","anim-color","anim-curve","anim-easing","anim-node-plugin","anim-scroll","anim-xy"],
      "app": ["app-base","app-transitions","lazy-model-list","model","model-list","model-sync-rest","router","view","view-node-map"],
      "attribute": ["attribute-base","attribute-complex"],
      "autocomplete": ["autocomplete-base","autocomplete-sources","autocomplete-list","autocomplete-plugin"],
      "base": ["base-base","base-pluginhost","base-build"],
      "cache": ["cache-base","cache-offline","cache-plugin"],
      "collection": ["array-extras","arraylist","arraylist-add","arraylist-filter","array-invoke"],
      "controller": ["router"],
      "dataschema": ["dataschema-base","dataschema-json","dataschema-xml","dataschema-array","dataschema-text"],
      "datasource": ["datasource-local","datasource-io","datasource-get","datasource-function","datasource-cache","datasource-jsonschema","datasource-xmlschema","datasource-arrayschema","datasource-textschema","datasource-polling"],
      "datatable": ["datatable-core","datatable-table","datatable-head","datatable-body","datatable-base","datatable-column-widths","datatable-message","datatable-mutable","datatable-sort","datatable-datasource"],
      "datatable-deprecated": ["datatable-base-deprecated","datatable-datasource-deprecated","datatable-sort-deprecated","datatable-scroll-deprecated"],
      "datatype": ["datatype-number","datatype-date","datatype-xml"],
      "datatype-date": ["datatype-date-parse","datatype-date-format"],
      "datatype-number": ["datatype-number-parse","datatype-number-format"],
      "datatype-xml": ["datatype-xml-parse","datatype-xml-format"],
      "dd": ["dd-ddm-base","dd-ddm","dd-ddm-drop","dd-drag","dd-proxy","dd-constrain","dd-drop","dd-scroll","dd-delegate"],
      "dom": ["dom-base","dom-screen","dom-style","selector-native","selector"],
      "editor": ["frame","editor-selection","exec-command","editor-base","editor-para","editor-br","editor-bidi","editor-tab","createlink-base"],
      "event": ["event-base","event-delegate","event-synthetic","event-mousewheel","event-mouseenter","event-key","event-focus","event-resize","event-hover","event-outside","event-touch","event-move","event-flick","event-valuechange"],
      "event-custom": ["event-custom-base","event-custom-complex"],
      "event-gestures": ["event-flick","event-move"],
      "handlebars": ["handlebars-compiler"],
      "highlight": ["highlight-base","highlight-accentfold"],
      "history": ["history-base","history-hash","history-hash-ie","history-html5"],
      "io": ["io-base","io-xdr","io-form","io-upload-iframe","io-queue"],
      "json": ["json-parse","json-stringify"],
      "loader": ["loader-base","loader-rollup","loader-yui3"],
      "node": ["node-base","node-event-delegate","node-pluginhost","node-screen","node-style"],
      "pluginhost": ["pluginhost-base","pluginhost-config"],
      "querystring": ["querystring-parse","querystring-stringify"],
      "recordset": ["recordset-base","recordset-sort","recordset-filter","recordset-indexer"],
      "resize": ["resize-base","resize-proxy","resize-constrain"],
      "slider": ["slider-base","slider-value-range","clickable-rail","range-slider"],
      "text": ["text-accentfold","text-wordbreak"],
      "widget": ["widget-base","widget-htmlparser","widget-skin","widget-uievents"]
  };
  
  
  }, '@VERSION@' );
  YUI.add('get', function(Y) {
  
  /*jslint boss:true, expr:true, laxbreak: true */
  
  /**
  Provides dynamic loading of remote JavaScript and CSS resources.
  
  @module get
  @class Get
  @static
  **/
  
  var Lang = Y.Lang,
  
      CUSTOM_ATTRS, // defined lazily in Y.Get.Transaction._createNode()
  
      Get, Transaction;
  
  Y.Get = Get = {
      // -- Public Properties ----------------------------------------------------
  
      /**
      Default options for CSS requests. Options specified here will override
      global defaults for CSS requests.
  
      See the `options` property for all available options.
  
      @property cssOptions
      @type Object
      @static
      @since 3.5.0
      **/
      cssOptions: {
          attributes: {
              rel: 'stylesheet'
          },
  
          doc         : Y.config.linkDoc || Y.config.doc,
          pollInterval: 50
      },
  
      /**
      Default options for JS requests. Options specified here will override global
      defaults for JS requests.
  
      See the `options` property for all available options.
  
      @property jsOptions
      @type Object
      @static
      @since 3.5.0
      **/
      jsOptions: {
          autopurge: true,
          doc      : Y.config.scriptDoc || Y.config.doc
      },
  
      /**
      Default options to use for all requests.
  
      Note that while all available options are documented here for ease of
      discovery, some options (like callback functions) only make sense at the
      transaction level.
  
      Callback functions specified via the options object or the `options`
      parameter of the `css()`, `js()`, or `load()` methods will receive the
      transaction object as a parameter. See `Y.Get.Transaction` for details on
      the properties and methods available on transactions.
  
      @static
      @since 3.5.0
      @property {Object} options
  
      @property {Boolean} [options.async=false] Whether or not to load scripts
          asynchronously, meaning they're requested in parallel and execution
          order is not guaranteed. Has no effect on CSS, since CSS is always
          loaded asynchronously.
  
      @property {Object} [options.attributes] HTML attribute name/value pairs that
          should be added to inserted nodes. By default, the `charset` attribute
          will be set to "utf-8" and nodes will be given an auto-generated `id`
          attribute, but you can override these with your own values if desired.
  
      @property {Boolean} [options.autopurge] Whether or not to automatically
          purge inserted nodes after the purge threshold is reached. This is
          `true` by default for JavaScript, but `false` for CSS since purging a
          CSS node will also remove any styling applied by the referenced file.
  
      @property {Object} [options.context] `this` object to use when calling
          callback functions. Defaults to the transaction object.
  
      @property {Mixed} [options.data] Arbitrary data object to pass to "on*"
          callbacks.
  
      @property {Document} [options.doc] Document into which nodes should be
          inserted. By default, the current document is used.
  
      @property {HTMLElement|String} [options.insertBefore] HTML element or id
          string of an element before which all generated nodes should be
          inserted. If not specified, Get will automatically determine the best
          place to insert nodes for maximum compatibility.
  
      @property {Function} [options.onEnd] Callback to execute after a transaction
          is complete, regardless of whether it succeeded or failed.
  
      @property {Function} [options.onFailure] Callback to execute after a
          transaction fails, times out, or is aborted.
  
      @property {Function} [options.onProgress] Callback to execute after each
          individual request in a transaction either succeeds or fails.
  
      @property {Function} [options.onSuccess] Callback to execute after a
          transaction completes successfully with no errors. Note that in browsers
          that don't support the `error` event on CSS `<link>` nodes, a failed CSS
          request may still be reported as a success because in these browsers
          it can be difficult or impossible to distinguish between success and
          failure for CSS resources.
  
      @property {Function} [options.onTimeout] Callback to execute after a
          transaction times out.
  
      @property {Number} [options.pollInterval=50] Polling interval (in
          milliseconds) for detecting CSS load completion in browsers that don't
          support the `load` event on `<link>` nodes. This isn't used for
          JavaScript.
  
      @property {Number} [options.purgethreshold=20] Number of nodes to insert
          before triggering an automatic purge when `autopurge` is `true`.
  
      @property {Number} [options.timeout] Number of milliseconds to wait before
          aborting a transaction. When a timeout occurs, the `onTimeout` callback
          is called, followed by `onFailure` and finally `onEnd`. By default,
          there is no timeout.
  
      @property {String} [options.type] Resource type ("css" or "js"). This option
          is set automatically by the `css()` and `js()` functions and will be
          ignored there, but may be useful when using the `load()` function. If
          not specified, the type will be inferred from the URL, defaulting to
          "js" if the URL doesn't contain a recognizable file extension.
      **/
      options: {
          attributes: {
              charset: 'utf-8'
          },
  
          purgethreshold: 20
      },
  
      // -- Protected Properties -------------------------------------------------
  
      /**
      Regex that matches a CSS URL. Used to guess the file type when it's not
      specified.
  
      @property REGEX_CSS
      @type RegExp
      @final
      @protected
      @static
      @since 3.5.0
      **/
      REGEX_CSS: /\.css(?:[?;].*)?$/i,
  
      /**
      Regex that matches a JS URL. Used to guess the file type when it's not
      specified.
  
      @property REGEX_JS
      @type RegExp
      @final
      @protected
      @static
      @since 3.5.0
      **/
      REGEX_JS : /\.js(?:[?;].*)?$/i,
  
      /**
      Contains information about the current environment, such as what script and
      link injection features it supports.
  
      This object is created and populated the first time the `_getEnv()` method
      is called.
  
      @property _env
      @type Object
      @protected
      @static
      @since 3.5.0
      **/
  
      /**
      Mapping of document _yuid strings to <head> or <base> node references so we
      don't have to look the node up each time we want to insert a request node.
  
      @property _insertCache
      @type Object
      @protected
      @static
      @since 3.5.0
      **/
      _insertCache: {},
  
      /**
      Information about the currently pending transaction, if any.
  
      This is actually an object with two properties: `callback`, containing the
      optional callback passed to `css()`, `load()`, or `js()`; and `transaction`,
      containing the actual transaction instance.
  
      @property _pending
      @type Object
      @protected
      @static
      @since 3.5.0
      **/
      _pending: null,
  
      /**
      HTML nodes eligible to be purged next time autopurge is triggered.
  
      @property _purgeNodes
      @type HTMLElement[]
      @protected
      @static
      @since 3.5.0
      **/
      _purgeNodes: [],
  
      /**
      Queued transactions and associated callbacks.
  
      @property _queue
      @type Object[]
      @protected
      @static
      @since 3.5.0
      **/
      _queue: [],
  
      // -- Public Methods -------------------------------------------------------
  
      /**
      Aborts the specified transaction.
  
      This will cause the transaction's `onFailure` callback to be called and
      will prevent any new script and link nodes from being added to the document,
      but any resources that have already been requested will continue loading
      (there's no safe way to prevent this, unfortunately).
  
      *Note:* This method is deprecated as of 3.5.0, and will be removed in a
      future version of YUI. Use the transaction-level `abort()` method instead.
  
      @method abort
      @param {Get.Transaction} transaction Transaction to abort.
      @deprecated Use the `abort()` method on the transaction instead.
      @static
      **/
      abort: function (transaction) {
          var i, id, item, len, pending;
  
  
          if (!transaction.abort) {
              id          = transaction;
              pending     = this._pending;
              transaction = null;
  
              if (pending && pending.transaction.id === id) {
                  transaction   = pending.transaction;
                  this._pending = null;
              } else {
                  for (i = 0, len = this._queue.length; i < len; ++i) {
                      item = this._queue[i].transaction;
  
                      if (item.id === id) {
                          transaction = item;
                          this._queue.splice(i, 1);
                          break;
                      }
                  }
              }
          }
  
          transaction && transaction.abort();
      },
  
      /**
      Loads one or more CSS files.
  
      The _urls_ parameter may be provided as a URL string, a request object,
      or an array of URL strings and/or request objects.
  
      A request object is just an object that contains a `url` property and zero
      or more options that should apply specifically to that request.
      Request-specific options take priority over transaction-level options and
      default options.
  
      URLs may be relative or absolute, and do not have to have the same origin
      as the current page.
  
      The `options` parameter may be omitted completely and a callback passed in
      its place, if desired.
  
      @example
  
          // Load a single CSS file and log a message on completion.
          Y.Get.css('foo.css', function (err) {
              if (err) {
              } else {
              }
          });
  
          // Load multiple CSS files and log a message when all have finished
          // loading.
          var urls = ['foo.css', 'http://example.com/bar.css', 'baz/quux.css'];
  
          Y.Get.css(urls, function (err) {
              if (err) {
              } else {
              }
          });
  
          // Specify transaction-level options, which will apply to all requests
          // within the transaction.
          Y.Get.css(urls, {
              attributes: {'class': 'my-css'},
              timeout   : 5000
          });
  
          // Specify per-request options, which override transaction-level and
          // default options.
          Y.Get.css([
              {url: 'foo.css', attributes: {id: 'foo'}},
              {url: 'bar.css', attributes: {id: 'bar', charset: 'iso-8859-1'}}
          ]);
  
      @method css
      @param {String|Object|Array} urls URL string, request object, or array
          of URLs and/or request objects to load.
      @param {Object} [options] Options for this transaction. See the
          `Y.Get.options` property for a complete list of available options.
      @param {Function} [callback] Callback function to be called on completion.
          This is a general callback and will be called before any more granular
          callbacks (`onSuccess`, `onFailure`, etc.) specified in the `options`
          object.
  
          @param {Array|null} callback.err Array of errors that occurred during
              the transaction, or `null` on success.
          @param {Get.Transaction} callback.transaction Transaction object.
  
      @return {Get.Transaction} Transaction object.
      @static
      **/
      css: function (urls, options, callback) {
          return this._load('css', urls, options, callback);
      },
  
      /**
      Loads one or more JavaScript resources.
  
      The _urls_ parameter may be provided as a URL string, a request object,
      or an array of URL strings and/or request objects.
  
      A request object is just an object that contains a `url` property and zero
      or more options that should apply specifically to that request.
      Request-specific options take priority over transaction-level options and
      default options.
  
      URLs may be relative or absolute, and do not have to have the same origin
      as the current page.
  
      The `options` parameter may be omitted completely and a callback passed in
      its place, if desired.
  
      Scripts will be executed in the order they're specified unless the `async`
      option is `true`, in which case they'll be loaded in parallel and executed
      in whatever order they finish loading.
  
      @example
  
          // Load a single JS file and log a message on completion.
          Y.Get.js('foo.js', function (err) {
              if (err) {
              } else {
              }
          });
  
          // Load multiple JS files, execute them in order, and log a message when
          // all have finished loading.
          var urls = ['foo.js', 'http://example.com/bar.js', 'baz/quux.js'];
  
          Y.Get.js(urls, function (err) {
              if (err) {
              } else {
              }
          });
  
          // Specify transaction-level options, which will apply to all requests
          // within the transaction.
          Y.Get.js(urls, {
              attributes: {'class': 'my-js'},
              timeout   : 5000
          });
  
          // Specify per-request options, which override transaction-level and
          // default options.
          Y.Get.js([
              {url: 'foo.js', attributes: {id: 'foo'}},
              {url: 'bar.js', attributes: {id: 'bar', charset: 'iso-8859-1'}}
          ]);
  
      @method js
      @param {String|Object|Array} urls URL string, request object, or array
          of URLs and/or request objects to load.
      @param {Object} [options] Options for this transaction. See the
          `Y.Get.options` property for a complete list of available options.
      @param {Function} [callback] Callback function to be called on completion.
          This is a general callback and will be called before any more granular
          callbacks (`onSuccess`, `onFailure`, etc.) specified in the `options`
          object.
  
          @param {Array|null} callback.err Array of errors that occurred during
              the transaction, or `null` on success.
          @param {Get.Transaction} callback.transaction Transaction object.
  
      @return {Get.Transaction} Transaction object.
      @since 3.5.0
      @static
      **/
      js: function (urls, options, callback) {
          return this._load('js', urls, options, callback);
      },
  
      /**
      Loads one or more CSS and/or JavaScript resources in the same transaction.
  
      Use this method when you want to load both CSS and JavaScript in a single
      transaction and be notified when all requested URLs have finished loading,
      regardless of type.
  
      Behavior and options are the same as for the `css()` and `js()` methods. If
      a resource type isn't specified in per-request options or transaction-level
      options, Get will guess the file type based on the URL's extension (`.css`
      or `.js`, with or without a following query string). If the file type can't
      be guessed from the URL, a warning will be logged and Get will assume the
      URL is a JavaScript resource.
  
      @example
  
          // Load both CSS and JS files in a single transaction, and log a message
          // when all files have finished loading.
          Y.Get.load(['foo.css', 'bar.js', 'baz.css'], function (err) {
              if (err) {
              } else {
              }
          });
  
      @method load
      @param {String|Object|Array} urls URL string, request object, or array
          of URLs and/or request objects to load.
      @param {Object} [options] Options for this transaction. See the
          `Y.Get.options` property for a complete list of available options.
      @param {Function} [callback] Callback function to be called on completion.
          This is a general callback and will be called before any more granular
          callbacks (`onSuccess`, `onFailure`, etc.) specified in the `options`
          object.
  
          @param {Array|null} err Array of errors that occurred during the
              transaction, or `null` on success.
          @param {Get.Transaction} Transaction object.
  
      @return {Get.Transaction} Transaction object.
      @since 3.5.0
      @static
      **/
      load: function (urls, options, callback) {
          return this._load(null, urls, options, callback);
      },
  
      // -- Protected Methods ----------------------------------------------------
  
      /**
      Triggers an automatic purge if the purge threshold has been reached.
  
      @method _autoPurge
      @param {Number} threshold Purge threshold to use, in milliseconds.
      @protected
      @since 3.5.0
      @static
      **/
      _autoPurge: function (threshold) {
          if (threshold && this._purgeNodes.length >= threshold) {
              this._purge(this._purgeNodes);
          }
      },
  
      /**
      Populates the `_env` property with information about the current
      environment.
  
      @method _getEnv
      @return {Object} Environment information.
      @protected
      @since 3.5.0
      @static
      **/
      _getEnv: function () {
          var doc = Y.config.doc,
              ua  = Y.UA;
  
          // Note: some of these checks require browser sniffs since it's not
          // feasible to load test files on every pageview just to perform a
          // feature test. I'm sorry if this makes you sad.
          return (this._env = {
              // True if this is a browser that supports disabling async mode on
              // dynamically created script nodes. See
              // https://developer.mozilla.org/En/HTML/Element/Script#Attributes
              async: doc && doc.createElement('script').async === true,
  
              // True if this browser fires an event when a dynamically injected
              // link node fails to load. This is currently true for Firefox 9+
              // and WebKit 535.24+.
              cssFail: ua.gecko >= 9 || ua.compareVersions(ua.webkit, 535.24) >= 0,
  
              // True if this browser fires an event when a dynamically injected
              // link node finishes loading. This is currently true for IE, Opera,
              // Firefox 9+, and WebKit 535.24+. Note that IE versions <9 fire the
              // DOM 0 "onload" event, but not "load". All versions of IE fire
              // "onload".
              // davglass: Seems that Chrome on Android needs this to be false.
              cssLoad: (
                      (!ua.gecko && !ua.webkit) || ua.gecko >= 9 ||
                      ua.compareVersions(ua.webkit, 535.24) >= 0
                  ) && !(ua.chrome && ua.chrome <= 18),
  
              // True if this browser preserves script execution order while
              // loading scripts in parallel as long as the script node's `async`
              // attribute is set to false to explicitly disable async execution.
              preservesScriptOrder: !!(ua.gecko || ua.opera)
          });
      },
  
      _getTransaction: function (urls, options) {
          var requests = [],
              i, len, req, url;
  
          if (!Lang.isArray(urls)) {
              urls = [urls];
          }
  
          options = Y.merge(this.options, options);
  
          // Clone the attributes object so we don't end up modifying it by ref.
          options.attributes = Y.merge(this.options.attributes,
                  options.attributes);
  
          for (i = 0, len = urls.length; i < len; ++i) {
              url = urls[i];
              req = {attributes: {}};
  
              // If `url` is a string, we create a URL object for it, then mix in
              // global options and request-specific options. If it's an object
              // with a "url" property, we assume it's a request object containing
              // URL-specific options.
              if (typeof url === 'string') {
                  req.url = url;
              } else if (url.url) {
                  // URL-specific options override both global defaults and
                  // request-specific options.
                  Y.mix(req, url, false, null, 0, true);
                  url = url.url; // Make url a string so we can use it later.
              } else {
                  continue;
              }
  
              Y.mix(req, options, false, null, 0, true);
  
              // If we didn't get an explicit type for this URL either in the
              // request options or the URL-specific options, try to determine
              // one from the file extension.
              if (!req.type) {
                  if (this.REGEX_CSS.test(url)) {
                      req.type = 'css';
                  } else {
                      if (!this.REGEX_JS.test(url)) {
                      }
  
                      req.type = 'js';
                  }
              }
  
              // Mix in type-specific default options, but don't overwrite any
              // options that have already been set.
              Y.mix(req, req.type === 'js' ? this.jsOptions : this.cssOptions,
                  false, null, 0, true);
  
              // Give the node an id attribute if it doesn't already have one.
              req.attributes.id || (req.attributes.id = Y.guid());
  
              // Backcompat for <3.5.0 behavior.
              if (req.win) {
                  req.doc = req.win.document;
              } else {
                  req.win = req.doc.defaultView || req.doc.parentWindow;
              }
  
              if (req.charset) {
                  req.attributes.charset = req.charset;
              }
  
              requests.push(req);
          }
  
          return new Transaction(requests, options);
      },
  
      _load: function (type, urls, options, callback) {
          var transaction;
  
          // Allow callback as third param.
          if (typeof options === 'function') {
              callback = options;
              options  = {};
          }
  
          options || (options = {});
          options.type = type;
  
          if (!this._env) {
              this._getEnv();
          }
  
          transaction = this._getTransaction(urls, options);
  
          this._queue.push({
              callback   : callback,
              transaction: transaction
          });
  
          this._next();
  
          return transaction;
      },
  
      _next: function () {
          var item;
  
          if (this._pending) {
              return;
          }
  
          item = this._queue.shift();
  
          if (item) {
              this._pending = item;
  
              item.transaction.execute(function () {
                  item.callback && item.callback.apply(this, arguments);
  
                  Get._pending = null;
                  Get._next();
              });
          }
      },
  
      _purge: function (nodes) {
          var purgeNodes    = this._purgeNodes,
              isTransaction = nodes !== purgeNodes,
              index, node;
  
          while (node = nodes.pop()) { // assignment
              // Don't purge nodes that haven't finished loading (or errored out),
              // since this can hang the transaction.
              if (!node._yuiget_finished) {
                  continue;
              }
  
              node.parentNode && node.parentNode.removeChild(node);
  
              // If this is a transaction-level purge and this node also exists in
              // the Get-level _purgeNodes array, we need to remove it from
              // _purgeNodes to avoid creating a memory leak. The indexOf lookup
              // sucks, but until we get WeakMaps, this is the least troublesome
              // way to do this (we can't just hold onto node ids because they may
              // not be in the same document).
              if (isTransaction) {
                  index = Y.Array.indexOf(purgeNodes, node);
  
                  if (index > -1) {
                      purgeNodes.splice(index, 1);
                  }
              }
          }
      }
  };
  
  /**
  Alias for `js()`.
  
  @method script
  @static
  **/
  Get.script = Get.js;
  
  /**
  Represents a Get transaction, which may contain requests for one or more JS or
  CSS files.
  
  This class should not be instantiated manually. Instances will be created and
  returned as needed by Y.Get's `css()`, `js()`, and `load()` methods.
  
  @class Get.Transaction
  @constructor
  @since 3.5.0
  **/
  Get.Transaction = Transaction = function (requests, options) {
      var self = this;
  
      self.id       = Transaction._lastId += 1;
      self.data     = options.data;
      self.errors   = [];
      self.nodes    = [];
      self.options  = options;
      self.requests = requests;
  
      self._callbacks = []; // callbacks to call after execution finishes
      self._queue     = [];
      self._waiting   = 0;
  
      // Deprecated pre-3.5.0 properties.
      self.tId = self.id; // Use `id` instead.
      self.win = options.win || Y.config.win;
  };
  
  /**
  Arbitrary data object associated with this transaction.
  
  This object comes from the options passed to `Get.css()`, `Get.js()`, or
  `Get.load()`, and will be `undefined` if no data object was specified.
  
  @property {Object} data
  **/
  
  /**
  Array of errors that have occurred during this transaction, if any.
  
  @since 3.5.0
  @property {Object[]} errors
  @property {String} errors.error Error message.
  @property {Object} errors.request Request object related to the error.
  **/
  
  /**
  Numeric id for this transaction, unique among all transactions within the same
  YUI sandbox in the current pageview.
  
  @property {Number} id
  @since 3.5.0
  **/
  
  /**
  HTMLElement nodes (native ones, not YUI Node instances) that have been inserted
  during the current transaction.
  
  @property {HTMLElement[]} nodes
  **/
  
  /**
  Options associated with this transaction.
  
  See `Get.options` for the full list of available options.
  
  @property {Object} options
  @since 3.5.0
  **/
  
  /**
  Request objects contained in this transaction. Each request object represents
  one CSS or JS URL that will be (or has been) requested and loaded into the page.
  
  @property {Object} requests
  @since 3.5.0
  **/
  
  /**
  Id of the most recent transaction.
  
  @property _lastId
  @type Number
  @protected
  @static
  **/
  Transaction._lastId = 0;
  
  Transaction.prototype = {
      // -- Public Properties ----------------------------------------------------
  
      /**
      Current state of this transaction. One of "new", "executing", or "done".
  
      @property _state
      @type String
      @protected
      **/
      _state: 'new', // "new", "executing", or "done"
  
      // -- Public Methods -------------------------------------------------------
  
      /**
      Aborts this transaction.
  
      This will cause the transaction's `onFailure` callback to be called and
      will prevent any new script and link nodes from being added to the document,
      but any resources that have already been requested will continue loading
      (there's no safe way to prevent this, unfortunately).
  
      @method abort
      @param {String} [msg="Aborted."] Optional message to use in the `errors`
          array describing why the transaction was aborted.
      **/
      abort: function (msg) {
          this._pending    = null;
          this._pendingCSS = null;
          this._pollTimer  = clearTimeout(this._pollTimer);
          this._queue      = [];
          this._waiting    = 0;
  
          this.errors.push({error: msg || 'Aborted'});
          this._finish();
      },
  
      /**
      Begins execting the transaction.
  
      There's usually no reason to call this manually, since Get will call it
      automatically when other pending transactions have finished. If you really
      want to execute your transaction before Get does, you can, but be aware that
      this transaction's scripts may end up executing before the scripts in other
      pending transactions.
  
      If the transaction is already executing, the specified callback (if any)
      will be queued and called after execution finishes. If the transaction has
      already finished, the callback will be called immediately (the transaction
      will not be executed again).
  
      @method execute
      @param {Function} callback Callback function to execute after all requests
          in the transaction are complete, or after the transaction is aborted.
      **/
      execute: function (callback) {
          var self     = this,
              requests = self.requests,
              state    = self._state,
              i, len, queue, req;
  
          if (state === 'done') {
              callback && callback(self.errors.length ? self.errors : null, self);
              return;
          } else {
              callback && self._callbacks.push(callback);
  
              if (state === 'executing') {
                  return;
              }
          }
  
          self._state = 'executing';
          self._queue = queue = [];
  
          if (self.options.timeout) {
              self._timeout = setTimeout(function () {
                  self.abort('Timeout');
              }, self.options.timeout);
          }
  
          for (i = 0, len = requests.length; i < len; ++i) {
              req = self.requests[i];
  
              if (req.async || req.type === 'css') {
                  // No need to queue CSS or fully async JS.
                  self._insert(req);
              } else {
                  queue.push(req);
              }
          }
  
          self._next();
      },
  
      /**
      Manually purges any `<script>` or `<link>` nodes this transaction has
      created.
  
      Be careful when purging a transaction that contains CSS requests, since
      removing `<link>` nodes will also remove any styles they applied.
  
      @method purge
      **/
      purge: function () {
          Get._purge(this.nodes);
      },
  
      // -- Protected Methods ----------------------------------------------------
      _createNode: function (name, attrs, doc) {
          var node = doc.createElement(name),
              attr, testEl;
  
          if (!CUSTOM_ATTRS) {
              // IE6 and IE7 expect property names rather than attribute names for
              // certain attributes. Rather than sniffing, we do a quick feature
              // test the first time _createNode() runs to determine whether we
              // need to provide a workaround.
              testEl = doc.createElement('div');
              testEl.setAttribute('class', 'a');
  
              CUSTOM_ATTRS = testEl.className === 'a' ? {} : {
                  'for'  : 'htmlFor',
                  'class': 'className'
              };
          }
  
          for (attr in attrs) {
              if (attrs.hasOwnProperty(attr)) {
                  node.setAttribute(CUSTOM_ATTRS[attr] || attr, attrs[attr]);
              }
          }
  
          return node;
      },
  
      _finish: function () {
          var errors  = this.errors.length ? this.errors : null,
              options = this.options,
              thisObj = options.context || this,
              data, i, len;
  
          if (this._state === 'done') {
              return;
          }
  
          this._state = 'done';
  
          for (i = 0, len = this._callbacks.length; i < len; ++i) {
              this._callbacks[i].call(thisObj, errors, this);
          }
  
          data = this._getEventData();
  
          if (errors) {
              if (options.onTimeout && errors[errors.length - 1].error === 'Timeout') {
                  options.onTimeout.call(thisObj, data);
              }
  
              if (options.onFailure) {
                  options.onFailure.call(thisObj, data);
              }
          } else if (options.onSuccess) {
              options.onSuccess.call(thisObj, data);
          }
  
          if (options.onEnd) {
              options.onEnd.call(thisObj, data);
          }
      },
  
      _getEventData: function (req) {
          if (req) {
              // This merge is necessary for backcompat. I hate it.
              return Y.merge(this, {
                  abort  : this.abort, // have to copy these because the prototype isn't preserved
                  purge  : this.purge,
                  request: req,
                  url    : req.url,
                  win    : req.win
              });
          } else {
              return this;
          }
      },
  
      _getInsertBefore: function (req) {
          var doc = req.doc,
              el  = req.insertBefore,
              cache, cachedNode, docStamp;
  
          if (el) {
              return typeof el === 'string' ? doc.getElementById(el) : el;
          }
  
          cache    = Get._insertCache;
          docStamp = Y.stamp(doc);
  
          if ((el = cache[docStamp])) { // assignment
              return el;
          }
  
          // Inserting before a <base> tag apparently works around an IE bug
          // (according to a comment from pre-3.5.0 Y.Get), but I'm not sure what
          // bug that is, exactly. Better safe than sorry?
          if ((el = doc.getElementsByTagName('base')[0])) { // assignment
              return (cache[docStamp] = el);
          }
  
          // Look for a <head> element.
          el = doc.head || doc.getElementsByTagName('head')[0];
  
          if (el) {
              // Create a marker node at the end of <head> to use as an insertion
              // point. Inserting before this node will ensure that all our CSS
              // gets inserted in the correct order, to maintain style precedence.
              el.appendChild(doc.createTextNode(''));
              return (cache[docStamp] = el.lastChild);
          }
  
          // If all else fails, just insert before the first script node on the
          // page, which is virtually guaranteed to exist.
          return (cache[docStamp] = doc.getElementsByTagName('script')[0]);
      },
  
      _insert: function (req) {
          var env          = Get._env,
              insertBefore = this._getInsertBefore(req),
              isScript     = req.type === 'js',
              node         = req.node,
              self         = this,
              ua           = Y.UA,
              cssTimeout, nodeType;
  
          if (!node) {
              if (isScript) {
                  nodeType = 'script';
              } else if (!env.cssLoad && ua.gecko) {
                  nodeType = 'style';
              } else {
                  nodeType = 'link';
              }
  
              node = req.node = this._createNode(nodeType, req.attributes,
                  req.doc);
          }
  
          function onError() {
              self._progress('Failed to load ' + req.url, req);
          }
  
          function onLoad() {
              if (cssTimeout) {
                  clearTimeout(cssTimeout);
              }
  
              self._progress(null, req);
          }
  
  
          // Deal with script asynchronicity.
          if (isScript) {
              node.setAttribute('src', req.url);
  
              if (req.async) {
                  // Explicitly indicate that we want the browser to execute this
                  // script asynchronously. This is necessary for older browsers
                  // like Firefox <4.
                  node.async = true;
              } else {
                  if (env.async) {
                      // This browser treats injected scripts as async by default
                      // (standard HTML5 behavior) but asynchronous loading isn't
                      // desired, so tell the browser not to mark this script as
                      // async.
                      node.async = false;
                  }
  
                  // If this browser doesn't preserve script execution order based
                  // on insertion order, we'll need to avoid inserting other
                  // scripts until this one finishes loading.
                  if (!env.preservesScriptOrder) {
                      this._pending = req;
                  }
              }
          } else {
              if (!env.cssLoad && ua.gecko) {
                  // In Firefox <9, we can import the requested URL into a <style>
                  // node and poll for the existence of node.sheet.cssRules. This
                  // gives us a reliable way to determine CSS load completion that
                  // also works for cross-domain stylesheets.
                  //
                  // Props to Zach Leatherman for calling my attention to this
                  // technique.
                  node.innerHTML = (req.attributes.charset ?
                      '@charset "' + req.attributes.charset + '";' : '') +
                      '@import "' + req.url + '";';
              } else {
                  node.setAttribute('href', req.url);
              }
          }
  
          // Inject the node.
          if (isScript && ua.ie && (ua.ie < 9 || (document.documentMode && document.documentMode < 9))) {
              // Script on IE < 9, and IE 9+ when in IE 8 or older modes, including quirks mode.
              node.onreadystatechange = function () {
                  if (/loaded|complete/.test(node.readyState)) {
                      node.onreadystatechange = null;
                      onLoad();
                  }
              };
          } else if (!isScript && !env.cssLoad) {
              // CSS on Firefox <9 or WebKit.
              this._poll(req);
          } else {
              // Script or CSS on everything else. Using DOM 0 events because that
              // evens the playing field with older IEs.
              node.onerror = onError;
              node.onload  = onLoad;
  
              // If this browser doesn't fire an event when CSS fails to load,
              // fail after a timeout to avoid blocking the transaction queue.
              if (!env.cssFail && !isScript) {
                  cssTimeout = setTimeout(onError, req.timeout || 3000);
              }
          }
  
          this._waiting += 1;
  
          this.nodes.push(node);
          insertBefore.parentNode.insertBefore(node, insertBefore);
      },
  
      _next: function () {
          if (this._pending) {
              return;
          }
  
          // If there are requests in the queue, insert the next queued request.
          // Otherwise, if we're waiting on already-inserted requests to finish,
          // wait longer. If there are no queued requests and we're not waiting
          // for anything to load, then we're done!
          if (this._queue.length) {
              this._insert(this._queue.shift());
          } else if (!this._waiting) {
              this._finish();
          }
      },
  
      _poll: function (newReq) {
          var self       = this,
              pendingCSS = self._pendingCSS,
              isWebKit   = Y.UA.webkit,
              i, hasRules, j, nodeHref, req, sheets;
  
          if (newReq) {
              pendingCSS || (pendingCSS = self._pendingCSS = []);
              pendingCSS.push(newReq);
  
              if (self._pollTimer) {
                  // A poll timeout is already pending, so no need to create a
                  // new one.
                  return;
              }
          }
  
          self._pollTimer = null;
  
          // Note: in both the WebKit and Gecko hacks below, a CSS URL that 404s
          // will still be treated as a success. There's no good workaround for
          // this.
  
          for (i = 0; i < pendingCSS.length; ++i) {
              req = pendingCSS[i];
  
              if (isWebKit) {
                  // Look for a stylesheet matching the pending URL.
                  sheets   = req.doc.styleSheets;
                  j        = sheets.length;
                  nodeHref = req.node.href;
  
                  while (--j >= 0) {
                      if (sheets[j].href === nodeHref) {
                          pendingCSS.splice(i, 1);
                          i -= 1;
                          self._progress(null, req);
                          break;
                      }
                  }
              } else {
                  // Many thanks to Zach Leatherman for calling my attention to
                  // the @import-based cross-domain technique used here, and to
                  // Oleg Slobodskoi for an earlier same-domain implementation.
                  //
                  // See Zach's blog for more details:
                  // http://www.zachleat.com/web/2010/07/29/load-css-dynamically/
                  try {
                      // We don't really need to store this value since we never
                      // use it again, but if we don't store it, Closure Compiler
                      // assumes the code is useless and removes it.
                      hasRules = !!req.node.sheet.cssRules;
  
                      // If we get here, the stylesheet has loaded.
                      pendingCSS.splice(i, 1);
                      i -= 1;
                      self._progress(null, req);
                  } catch (ex) {
                      // An exception means the stylesheet is still loading.
                  }
              }
          }
  
          if (pendingCSS.length) {
              self._pollTimer = setTimeout(function () {
                  self._poll.call(self);
              }, self.options.pollInterval);
          }
      },
  
      _progress: function (err, req) {
          var options = this.options;
  
          if (err) {
              req.error = err;
  
              this.errors.push({
                  error  : err,
                  request: req
              });
  
          }
  
          req.node._yuiget_finished = req.finished = true;
  
          if (options.onProgress) {
              options.onProgress.call(options.context || this,
                  this._getEventData(req));
          }
  
          if (req.autopurge) {
              // Pre-3.5.0 Get always excludes the most recent node from an
              // autopurge. I find this odd, but I'm keeping that behavior for
              // the sake of backcompat.
              Get._autoPurge(this.options.purgethreshold);
              Get._purgeNodes.push(req.node);
          }
  
          if (this._pending === req) {
              this._pending = null;
          }
  
          this._waiting -= 1;
          this._next();
      }
  };
  
  
  }, '@VERSION@' ,{requires:['yui-base']});
  YUI.add('features', function(Y) {
  
  var feature_tests = {};
  
  /**
  Contains the core of YUI's feature test architecture.
  @module features
  */
  
  /**
  * Feature detection
  * @class Features
  * @static
  */
  
  Y.mix(Y.namespace('Features'), {
      
      /**
      * Object hash of all registered feature tests
      * @property tests
      * @type Object
      */
      tests: feature_tests,
      
      /**
      * Add a test to the system
      * 
      *   ```
      *   Y.Features.add("load", "1", {});
      *   ```
      * 
      * @method add
      * @param {String} cat The category, right now only 'load' is supported
      * @param {String} name The number sequence of the test, how it's reported in the URL or config: 1, 2, 3
      * @param {Object} o Object containing test properties
      * @param {String} o.name The name of the test
      * @param {Function} o.test The test function to execute, the only argument to the function is the `Y` instance
      * @param {String} o.trigger The module that triggers this test.
      */
      add: function(cat, name, o) {
          feature_tests[cat] = feature_tests[cat] || {};
          feature_tests[cat][name] = o;
      },
      /**
      * Execute all tests of a given category and return the serialized results
      *
      *   ```
      *   caps=1:1;2:1;3:0
      *   ```
      * @method all
      * @param {String} cat The category to execute
      * @param {Array} args The arguments to pass to the test function
      * @return {String} A semi-colon separated string of tests and their success/failure: 1:1;2:1;3:0
      */
      all: function(cat, args) {
          var cat_o = feature_tests[cat],
              // results = {};
              result = [];
          if (cat_o) {
              Y.Object.each(cat_o, function(v, k) {
                  result.push(k + ':' + (Y.Features.test(cat, k, args) ? 1 : 0));
              });
          }
  
          return (result.length) ? result.join(';') : '';
      },
      /**
      * Run a sepecific test and return a Boolean response.
      *
      *   ```
      *   Y.Features.test("load", "1");
      *   ```
      *
      * @method test
      * @param {String} cat The category of the test to run
      * @param {String} name The name of the test to run
      * @param {Array} args The arguments to pass to the test function
      * @return {Boolean} True or false if the test passed/failed.
      */
      test: function(cat, name, args) {
          args = args || [];
          var result, ua, test,
              cat_o = feature_tests[cat],
              feature = cat_o && cat_o[name];
  
          if (!feature) {
          } else {
  
              result = feature.result;
  
              if (Y.Lang.isUndefined(result)) {
  
                  ua = feature.ua;
                  if (ua) {
                      result = (Y.UA[ua]);
                  }
  
                  test = feature.test;
                  if (test && ((!ua) || result)) {
                      result = test.apply(Y, args);
                  }
  
                  feature.result = result;
              }
          }
  
          return result;
      }
  });
  
  // Y.Features.add("load", "1", {});
  // Y.Features.test("load", "1");
  // caps=1:1;2:0;3:1;
  
  /* This file is auto-generated by src/loader/scripts/meta_join.js */
  var add = Y.Features.add;
  // app-transitions-native
  add('load', '0', {
      "name": "app-transitions-native",
      "test": function (Y) {
      var doc  = Y.config.doc,
          node = doc ? doc.documentElement : null;
  
      if (node && node.style) {
          return ('MozTransition' in node.style || 'WebkitTransition' in node.style);
      }
  
      return false;
  },
      "trigger": "app-transitions"
  });
  // autocomplete-list-keys
  add('load', '1', {
      "name": "autocomplete-list-keys",
      "test": function (Y) {
      // Only add keyboard support to autocomplete-list if this doesn't appear to
      // be an iOS or Android-based mobile device.
      //
      // There's currently no feasible way to actually detect whether a device has
      // a hardware keyboard, so this sniff will have to do. It can easily be
      // overridden by manually loading the autocomplete-list-keys module.
      //
      // Worth noting: even though iOS supports bluetooth keyboards, Mobile Safari
      // doesn't fire the keyboard events used by AutoCompleteList, so there's
      // no point loading the -keys module even when a bluetooth keyboard may be
      // available.
      return !(Y.UA.ios || Y.UA.android);
  },
      "trigger": "autocomplete-list"
  });
  // dd-gestures
  add('load', '2', {
      "name": "dd-gestures",
      "test": function(Y) {
      return ((Y.config.win && ("ontouchstart" in Y.config.win)) && !(Y.UA.chrome && Y.UA.chrome < 6));
  },
      "trigger": "dd-drag"
  });
  // dom-style-ie
  add('load', '3', {
      "name": "dom-style-ie",
      "test": function (Y) {
  
      var testFeature = Y.Features.test,
          addFeature = Y.Features.add,
          WINDOW = Y.config.win,
          DOCUMENT = Y.config.doc,
          DOCUMENT_ELEMENT = 'documentElement',
          ret = false;
  
      addFeature('style', 'computedStyle', {
          test: function() {
              return WINDOW && 'getComputedStyle' in WINDOW;
          }
      });
  
      addFeature('style', 'opacity', {
          test: function() {
              return DOCUMENT && 'opacity' in DOCUMENT[DOCUMENT_ELEMENT].style;
          }
      });
  
      ret =  (!testFeature('style', 'opacity') &&
              !testFeature('style', 'computedStyle'));
  
      return ret;
  },
      "trigger": "dom-style"
  });
  // editor-para-ie
  add('load', '4', {
      "name": "editor-para-ie",
      "trigger": "editor-para",
      "ua": "ie",
      "when": "instead"
  });
  // event-base-ie
  add('load', '5', {
      "name": "event-base-ie",
      "test": function(Y) {
      var imp = Y.config.doc && Y.config.doc.implementation;
      return (imp && (!imp.hasFeature('Events', '2.0')));
  },
      "trigger": "node-base"
  });
  // graphics-canvas
  add('load', '6', {
      "name": "graphics-canvas",
      "test": function(Y) {
      var DOCUMENT = Y.config.doc,
          useCanvas = Y.config.defaultGraphicEngine && Y.config.defaultGraphicEngine == "canvas",
  		canvas = DOCUMENT && DOCUMENT.createElement("canvas"),
          svg = (DOCUMENT && DOCUMENT.implementation.hasFeature("http://www.w3.org/TR/SVG11/feature#BasicStructure", "1.1"));
      return (!svg || useCanvas) && (canvas && canvas.getContext && canvas.getContext("2d"));
  },
      "trigger": "graphics"
  });
  // graphics-canvas-default
  add('load', '7', {
      "name": "graphics-canvas-default",
      "test": function(Y) {
      var DOCUMENT = Y.config.doc,
          useCanvas = Y.config.defaultGraphicEngine && Y.config.defaultGraphicEngine == "canvas",
  		canvas = DOCUMENT && DOCUMENT.createElement("canvas"),
          svg = (DOCUMENT && DOCUMENT.implementation.hasFeature("http://www.w3.org/TR/SVG11/feature#BasicStructure", "1.1"));
      return (!svg || useCanvas) && (canvas && canvas.getContext && canvas.getContext("2d"));
  },
      "trigger": "graphics"
  });
  // graphics-svg
  add('load', '8', {
      "name": "graphics-svg",
      "test": function(Y) {
      var DOCUMENT = Y.config.doc,
          useSVG = !Y.config.defaultGraphicEngine || Y.config.defaultGraphicEngine != "canvas",
  		canvas = DOCUMENT && DOCUMENT.createElement("canvas"),
          svg = (DOCUMENT && DOCUMENT.implementation.hasFeature("http://www.w3.org/TR/SVG11/feature#BasicStructure", "1.1"));
      
      return svg && (useSVG || !canvas);
  },
      "trigger": "graphics"
  });
  // graphics-svg-default
  add('load', '9', {
      "name": "graphics-svg-default",
      "test": function(Y) {
      var DOCUMENT = Y.config.doc,
          useSVG = !Y.config.defaultGraphicEngine || Y.config.defaultGraphicEngine != "canvas",
  		canvas = DOCUMENT && DOCUMENT.createElement("canvas"),
          svg = (DOCUMENT && DOCUMENT.implementation.hasFeature("http://www.w3.org/TR/SVG11/feature#BasicStructure", "1.1"));
      
      return svg && (useSVG || !canvas);
  },
      "trigger": "graphics"
  });
  // graphics-vml
  add('load', '10', {
      "name": "graphics-vml",
      "test": function(Y) {
      var DOCUMENT = Y.config.doc,
  		canvas = DOCUMENT && DOCUMENT.createElement("canvas");
      return (DOCUMENT && !DOCUMENT.implementation.hasFeature("http://www.w3.org/TR/SVG11/feature#BasicStructure", "1.1") && (!canvas || !canvas.getContext || !canvas.getContext("2d")));
  },
      "trigger": "graphics"
  });
  // graphics-vml-default
  add('load', '11', {
      "name": "graphics-vml-default",
      "test": function(Y) {
      var DOCUMENT = Y.config.doc,
  		canvas = DOCUMENT && DOCUMENT.createElement("canvas");
      return (DOCUMENT && !DOCUMENT.implementation.hasFeature("http://www.w3.org/TR/SVG11/feature#BasicStructure", "1.1") && (!canvas || !canvas.getContext || !canvas.getContext("2d")));
  },
      "trigger": "graphics"
  });
  // history-hash-ie
  add('load', '12', {
      "name": "history-hash-ie",
      "test": function (Y) {
      var docMode = Y.config.doc && Y.config.doc.documentMode;
  
      return Y.UA.ie && (!('onhashchange' in Y.config.win) ||
              !docMode || docMode < 8);
  },
      "trigger": "history-hash"
  });
  // io-nodejs
  add('load', '13', {
      "name": "io-nodejs",
      "trigger": "io-base",
      "ua": "nodejs"
  });
  // scrollview-base-ie
  add('load', '14', {
      "name": "scrollview-base-ie",
      "trigger": "scrollview-base",
      "ua": "ie"
  });
  // selector-css2
  add('load', '15', {
      "name": "selector-css2",
      "test": function (Y) {
      var DOCUMENT = Y.config.doc,
          ret = DOCUMENT && !('querySelectorAll' in DOCUMENT);
  
      return ret;
  },
      "trigger": "selector"
  });
  // transition-timer
  add('load', '16', {
      "name": "transition-timer",
      "test": function (Y) {
      var DOCUMENT = Y.config.doc,
          node = (DOCUMENT) ? DOCUMENT.documentElement: null,
          ret = true;
  
      if (node && node.style) {
          ret = !('MozTransition' in node.style || 'WebkitTransition' in node.style);
      } 
  
      return ret;
  },
      "trigger": "transition"
  });
  // widget-base-ie
  add('load', '17', {
      "name": "widget-base-ie",
      "trigger": "widget-base",
      "ua": "ie"
  });
  
  
  }, '@VERSION@' ,{requires:['yui-base']});
  YUI.add('intl-base', function(Y) {
  
  /**
   * The Intl utility provides a central location for managing sets of
   * localized resources (strings and formatting patterns).
   *
   * @class Intl
   * @uses EventTarget
   * @static
   */
  
  var SPLIT_REGEX = /[, ]/;
  
  Y.mix(Y.namespace('Intl'), {
  
   /**
      * Returns the language among those available that
      * best matches the preferred language list, using the Lookup
      * algorithm of BCP 47.
      * If none of the available languages meets the user's preferences,
      * then "" is returned.
      * Extended language ranges are not supported.
      *
      * @method lookupBestLang
      * @param {String[] | String} preferredLanguages The list of preferred
      * languages in descending preference order, represented as BCP 47
      * language tags. A string array or a comma-separated list.
      * @param {String[]} availableLanguages The list of languages
      * that the application supports, represented as BCP 47 language
      * tags.
      *
      * @return {String} The available language that best matches the
      * preferred language list, or "".
      * @since 3.1.0
      */
      lookupBestLang: function(preferredLanguages, availableLanguages) {
  
          var i, language, result, index;
  
          // check whether the list of available languages contains language;
          // if so return it
          function scan(language) {
              var i;
              for (i = 0; i < availableLanguages.length; i += 1) {
                  if (language.toLowerCase() ===
                              availableLanguages[i].toLowerCase()) {
                      return availableLanguages[i];
                  }
              }
          }
  
          if (Y.Lang.isString(preferredLanguages)) {
              preferredLanguages = preferredLanguages.split(SPLIT_REGEX);
          }
  
          for (i = 0; i < preferredLanguages.length; i += 1) {
              language = preferredLanguages[i];
              if (!language || language === '*') {
                  continue;
              }
              // check the fallback sequence for one language
              while (language.length > 0) {
                  result = scan(language);
                  if (result) {
                      return result;
                  } else {
                      index = language.lastIndexOf('-');
                      if (index >= 0) {
                          language = language.substring(0, index);
                          // one-character subtags get cut along with the
                          // following subtag
                          if (index >= 2 && language.charAt(index - 2) === '-') {
                              language = language.substring(0, index - 2);
                          }
                      } else {
                          // nothing available for this language
                          break;
                      }
                  }
              }
          }
  
          return '';
      }
  });
  
  
  }, '@VERSION@' ,{requires:['yui-base']});
  YUI.add('yui-log', function(Y) {
  
  /**
   * Provides console log capability and exposes a custom event for
   * console implementations. This module is a `core` YUI module, <a href="../classes/YUI.html#method_log">it's documentation is located under the YUI class</a>.
   *
   * @module yui
   * @submodule yui-log
   */
  
  var INSTANCE = Y,
      LOGEVENT = 'yui:log',
      UNDEFINED = 'undefined',
      LEVELS = { debug: 1,
                 info: 1,
                 warn: 1,
                 error: 1 };
  
  /**
   * If the 'debug' config is true, a 'yui:log' event will be
   * dispatched, which the Console widget and anything else
   * can consume.  If the 'useBrowserConsole' config is true, it will
   * write to the browser console if available.  YUI-specific log
   * messages will only be present in the -debug versions of the
   * JS files.  The build system is supposed to remove log statements
   * from the raw and minified versions of the files.
   *
   * @method log
   * @for YUI
   * @param  {String}  msg  The message to log.
   * @param  {String}  cat  The log category for the message.  Default
   *                        categories are "info", "warn", "error", time".
   *                        Custom categories can be used as well. (opt).
   * @param  {String}  src  The source of the the message (opt).
   * @param  {boolean} silent If true, the log event won't fire.
   * @return {YUI}      YUI instance.
   */
  INSTANCE.log = function(msg, cat, src, silent) {
      var bail, excl, incl, m, f,
          Y = INSTANCE,
          c = Y.config,
          publisher = (Y.fire) ? Y : YUI.Env.globalEvents;
      // suppress log message if the config is off or the event stack
      // or the event call stack contains a consumer of the yui:log event
      if (c.debug) {
          // apply source filters
          src = src || "";
          if (typeof src !== "undefined") {
              excl = c.logExclude;
              incl = c.logInclude;
              if (incl && !(src in incl)) {
                  bail = 1;
              } else if (incl && (src in incl)) {
                  bail = !incl[src];
              } else if (excl && (src in excl)) {
                  bail = excl[src];
              }
          }
          if (!bail) {
              if (c.useBrowserConsole) {
                  m = (src) ? src + ': ' + msg : msg;
                  if (Y.Lang.isFunction(c.logFn)) {
                      c.logFn.call(Y, msg, cat, src);
                  } else if (typeof console != UNDEFINED && console.log) {
                      f = (cat && console[cat] && (cat in LEVELS)) ? cat : 'log';
                      console[f](m);
                  } else if (typeof opera != UNDEFINED) {
                      opera.postError(m);
                  }
              }
  
              if (publisher && !silent) {
  
                  if (publisher == Y && (!publisher.getEvent(LOGEVENT))) {
                      publisher.publish(LOGEVENT, {
                          broadcast: 2
                      });
                  }
  
                  publisher.fire(LOGEVENT, {
                      msg: msg,
                      cat: cat,
                      src: src
                  });
              }
          }
      }
  
      return Y;
  };
  
  /**
   * Write a system message.  This message will be preserved in the
   * minified and raw versions of the YUI files, unlike log statements.
   * @method message
   * @for YUI
   * @param  {String}  msg  The message to log.
   * @param  {String}  cat  The log category for the message.  Default
   *                        categories are "info", "warn", "error", time".
   *                        Custom categories can be used as well. (opt).
   * @param  {String}  src  The source of the the message (opt).
   * @param  {boolean} silent If true, the log event won't fire.
   * @return {YUI}      YUI instance.
   */
  INSTANCE.message = function() {
      return INSTANCE.log.apply(INSTANCE, arguments);
  };
  
  
  }, '@VERSION@' ,{requires:['yui-base']});
  YUI.add('yui-later', function(Y) {
  
  /**
   * Provides a setTimeout/setInterval wrapper. This module is a `core` YUI module, <a href="../classes/YUI.html#method_later">it's documentation is located under the YUI class</a>.
   *
   * @module yui
   * @submodule yui-later
   */
  
  var NO_ARGS = [];
  
  /**
   * Executes the supplied function in the context of the supplied
   * object 'when' milliseconds later.  Executes the function a
   * single time unless periodic is set to true.
   * @for YUI
   * @method later
   * @param when {int} the number of milliseconds to wait until the fn
   * is executed.
   * @param o the context object.
   * @param fn {Function|String} the function to execute or the name of
   * the method in the 'o' object to execute.
   * @param data [Array] data that is provided to the function.  This
   * accepts either a single item or an array.  If an array is provided,
   * the function is executed with one parameter for each array item.
   * If you need to pass a single array parameter, it needs to be wrapped
   * in an array [myarray].
   *
   * Note: native methods in IE may not have the call and apply methods.
   * In this case, it will work, but you are limited to four arguments.
   *
   * @param periodic {boolean} if true, executes continuously at supplied
   * interval until canceled.
   * @return {object} a timer object. Call the cancel() method on this
   * object to stop the timer.
   */
  Y.later = function(when, o, fn, data, periodic) {
      when = when || 0;
      data = (!Y.Lang.isUndefined(data)) ? Y.Array(data) : NO_ARGS;
      o = o || Y.config.win || Y;
  
      var cancelled = false,
          method = (o && Y.Lang.isString(fn)) ? o[fn] : fn,
          wrapper = function() {
              // IE 8- may execute a setInterval callback one last time
              // after clearInterval was called, so in order to preserve
              // the cancel() === no more runny-run, we have to jump through
              // an extra hoop.
              if (!cancelled) {
                  if (!method.apply) {
                      method(data[0], data[1], data[2], data[3]);
                  } else {
                      method.apply(o, data || NO_ARGS);
                  }
              }
          },
          id = (periodic) ? setInterval(wrapper, when) : setTimeout(wrapper, when);
  
      return {
          id: id,
          interval: periodic,
          cancel: function() {
              cancelled = true;
              if (this.interval) {
                  clearInterval(id);
              } else {
                  clearTimeout(id);
              }
          }
      };
  };
  
  Y.Lang.later = Y.later;
  
  
  
  }, '@VERSION@' ,{requires:['yui-base']});
  
  
  YUI.add('yui', function(Y){}, '@VERSION@' ,{use:['yui-base','get','features','intl-base','yui-log','yui-later']});
  
  YUI.add('oop', function(Y) {
  
  /**
  Adds object inheritance and manipulation utilities to the YUI instance. This
  module is required by most YUI components.
  
  @module oop
  **/
  
  var L            = Y.Lang,
      A            = Y.Array,
      OP           = Object.prototype,
      CLONE_MARKER = '_~yuim~_',
  
      hasOwn   = OP.hasOwnProperty,
      toString = OP.toString;
  
  function dispatch(o, f, c, proto, action) {
      if (o && o[action] && o !== Y) {
          return o[action].call(o, f, c);
      } else {
          switch (A.test(o)) {
              case 1:
                  return A[action](o, f, c);
              case 2:
                  return A[action](Y.Array(o, 0, true), f, c);
              default:
                  return Y.Object[action](o, f, c, proto);
          }
      }
  }
  
  /**
  Augments the _receiver_ with prototype properties from the _supplier_. The
  receiver may be a constructor function or an object. The supplier must be a
  constructor function.
  
  If the _receiver_ is an object, then the _supplier_ constructor will be called
  immediately after _receiver_ is augmented, with _receiver_ as the `this` object.
  
  If the _receiver_ is a constructor function, then all prototype methods of
  _supplier_ that are copied to _receiver_ will be sequestered, and the
  _supplier_ constructor will not be called immediately. The first time any
  sequestered method is called on the _receiver_'s prototype, all sequestered
  methods will be immediately copied to the _receiver_'s prototype, the
  _supplier_'s constructor will be executed, and finally the newly unsequestered
  method that was called will be executed.
  
  This sequestering logic sounds like a bunch of complicated voodoo, but it makes
  it cheap to perform frequent augmentation by ensuring that suppliers'
  constructors are only called if a supplied method is actually used. If none of
  the supplied methods is ever used, then there's no need to take the performance
  hit of calling the _supplier_'s constructor.
  
  @method augment
  @param {Function|Object} receiver Object or function to be augmented.
  @param {Function} supplier Function that supplies the prototype properties with
    which to augment the _receiver_.
  @param {Boolean} [overwrite=false] If `true`, properties already on the receiver
    will be overwritten if found on the supplier's prototype.
  @param {String[]} [whitelist] An array of property names. If specified,
    only the whitelisted prototype properties will be applied to the receiver, and
    all others will be ignored.
  @param {Array|any} [args] Argument or array of arguments to pass to the
    supplier's constructor when initializing.
  @return {Function} Augmented object.
  @for YUI
  **/
  Y.augment = function (receiver, supplier, overwrite, whitelist, args) {
      var rProto    = receiver.prototype,
          sequester = rProto && supplier,
          sProto    = supplier.prototype,
          to        = rProto || receiver,
  
          copy,
          newPrototype,
          replacements,
          sequestered,
          unsequester;
  
      args = args ? Y.Array(args) : [];
  
      if (sequester) {
          newPrototype = {};
          replacements = {};
          sequestered  = {};
  
          copy = function (value, key) {
              if (overwrite || !(key in rProto)) {
                  if (toString.call(value) === '[object Function]') {
                      sequestered[key] = value;
  
                      newPrototype[key] = replacements[key] = function () {
                          return unsequester(this, value, arguments);
                      };
                  } else {
                      newPrototype[key] = value;
                  }
              }
          };
  
          unsequester = function (instance, fn, fnArgs) {
              // Unsequester all sequestered functions.
              for (var key in sequestered) {
                  if (hasOwn.call(sequestered, key)
                          && instance[key] === replacements[key]) {
  
                      instance[key] = sequestered[key];
                  }
              }
  
              // Execute the supplier constructor.
              supplier.apply(instance, args);
  
              // Finally, execute the original sequestered function.
              return fn.apply(instance, fnArgs);
          };
  
          if (whitelist) {
              Y.Array.each(whitelist, function (name) {
                  if (name in sProto) {
                      copy(sProto[name], name);
                  }
              });
          } else {
              Y.Object.each(sProto, copy, null, true);
          }
      }
  
      Y.mix(to, newPrototype || sProto, overwrite, whitelist);
  
      if (!sequester) {
          supplier.apply(to, args);
      }
  
      return receiver;
  };
  
  /**
   * Copies object properties from the supplier to the receiver. If the target has
   * the property, and the property is an object, the target object will be
   * augmented with the supplier's value.
   *
   * @method aggregate
   * @param {Object} receiver Object to receive the augmentation.
   * @param {Object} supplier Object that supplies the properties with which to
   *     augment the receiver.
   * @param {Boolean} [overwrite=false] If `true`, properties already on the receiver
   *     will be overwritten if found on the supplier.
   * @param {String[]} [whitelist] Whitelist. If supplied, only properties in this
   *     list will be applied to the receiver.
   * @return {Object} Augmented object.
   */
  Y.aggregate = function(r, s, ov, wl) {
      return Y.mix(r, s, ov, wl, 0, true);
  };
  
  /**
   * Utility to set up the prototype, constructor and superclass properties to
   * support an inheritance strategy that can chain constructors and methods.
   * Static members will not be inherited.
   *
   * @method extend
   * @param {function} r   the object to modify.
   * @param {function} s the object to inherit.
   * @param {object} px prototype properties to add/override.
   * @param {object} sx static properties to add/override.
   * @return {object} the extended object.
   */
  Y.extend = function(r, s, px, sx) {
      if (!s || !r) {
          Y.error('extend failed, verify dependencies');
      }
  
      var sp = s.prototype, rp = Y.Object(sp);
      r.prototype = rp;
  
      rp.constructor = r;
      r.superclass = sp;
  
      // assign constructor property
      if (s != Object && sp.constructor == OP.constructor) {
          sp.constructor = s;
      }
  
      // add prototype overrides
      if (px) {
          Y.mix(rp, px, true);
      }
  
      // add object overrides
      if (sx) {
          Y.mix(r, sx, true);
      }
  
      return r;
  };
  
  /**
   * Executes the supplied function for each item in
   * a collection.  Supports arrays, objects, and
   * NodeLists
   * @method each
   * @param {object} o the object to iterate.
   * @param {function} f the function to execute.  This function
   * receives the value, key, and object as parameters.
   * @param {object} c the execution context for the function.
   * @param {boolean} proto if true, prototype properties are
   * iterated on objects.
   * @return {YUI} the YUI instance.
   */
  Y.each = function(o, f, c, proto) {
      return dispatch(o, f, c, proto, 'each');
  };
  
  /**
   * Executes the supplied function for each item in
   * a collection.  The operation stops if the function
   * returns true. Supports arrays, objects, and
   * NodeLists.
   * @method some
   * @param {object} o the object to iterate.
   * @param {function} f the function to execute.  This function
   * receives the value, key, and object as parameters.
   * @param {object} c the execution context for the function.
   * @param {boolean} proto if true, prototype properties are
   * iterated on objects.
   * @return {boolean} true if the function ever returns true,
   * false otherwise.
   */
  Y.some = function(o, f, c, proto) {
      return dispatch(o, f, c, proto, 'some');
  };
  
  /**
   * Deep object/array copy.  Function clones are actually
   * wrappers around the original function.
   * Array-like objects are treated as arrays.
   * Primitives are returned untouched.  Optionally, a
   * function can be provided to handle other data types,
   * filter keys, validate values, etc.
   *
   * @method clone
   * @param {object} o what to clone.
   * @param {boolean} safe if true, objects will not have prototype
   * items from the source.  If false, they will.  In this case, the
   * original is initially protected, but the clone is not completely
   * immune from changes to the source object prototype.  Also, cloned
   * prototype items that are deleted from the clone will result
   * in the value of the source prototype being exposed.  If operating
   * on a non-safe clone, items should be nulled out rather than deleted.
   * @param {function} f optional function to apply to each item in a
   * collection; it will be executed prior to applying the value to
   * the new object.  Return false to prevent the copy.
   * @param {object} c optional execution context for f.
   * @param {object} owner Owner object passed when clone is iterating
   * an object.  Used to set up context for cloned functions.
   * @param {object} cloned hash of previously cloned objects to avoid
   * multiple clones.
   * @return {Array|Object} the cloned object.
   */
  Y.clone = function(o, safe, f, c, owner, cloned) {
  
      if (!L.isObject(o)) {
          return o;
      }
  
      // @todo cloning YUI instances doesn't currently work
      if (Y.instanceOf(o, YUI)) {
          return o;
      }
  
      var o2, marked = cloned || {}, stamp,
          yeach = Y.each;
  
      switch (L.type(o)) {
          case 'date':
              return new Date(o);
          case 'regexp':
              // if we do this we need to set the flags too
              // return new RegExp(o.source);
              return o;
          case 'function':
              // o2 = Y.bind(o, owner);
              // break;
              return o;
          case 'array':
              o2 = [];
              break;
          default:
  
              // #2528250 only one clone of a given object should be created.
              if (o[CLONE_MARKER]) {
                  return marked[o[CLONE_MARKER]];
              }
  
              stamp = Y.guid();
  
              o2 = (safe) ? {} : Y.Object(o);
  
              o[CLONE_MARKER] = stamp;
              marked[stamp] = o;
      }
  
      // #2528250 don't try to clone element properties
      if (!o.addEventListener && !o.attachEvent) {
          yeach(o, function(v, k) {
  if ((k || k === 0) && (!f || (f.call(c || this, v, k, this, o) !== false))) {
                  if (k !== CLONE_MARKER) {
                      if (k == 'prototype') {
                          // skip the prototype
                      // } else if (o[k] === o) {
                      //     this[k] = this;
                      } else {
                          this[k] =
                              Y.clone(v, safe, f, c, owner || o, marked);
                      }
                  }
              }
          }, o2);
      }
  
      if (!cloned) {
          Y.Object.each(marked, function(v, k) {
              if (v[CLONE_MARKER]) {
                  try {
                      delete v[CLONE_MARKER];
                  } catch (e) {
                      v[CLONE_MARKER] = null;
                  }
              }
          }, this);
          marked = null;
      }
  
      return o2;
  };
  
  
  /**
   * Returns a function that will execute the supplied function in the
   * supplied object's context, optionally adding any additional
   * supplied parameters to the beginning of the arguments collection the
   * supplied to the function.
   *
   * @method bind
   * @param {Function|String} f the function to bind, or a function name
   * to execute on the context object.
   * @param {object} c the execution context.
   * @param {any} args* 0..n arguments to include before the arguments the
   * function is executed with.
   * @return {function} the wrapped function.
   */
  Y.bind = function(f, c) {
      var xargs = arguments.length > 2 ?
              Y.Array(arguments, 2, true) : null;
      return function() {
          var fn = L.isString(f) ? c[f] : f,
              args = (xargs) ?
                  xargs.concat(Y.Array(arguments, 0, true)) : arguments;
          return fn.apply(c || fn, args);
      };
  };
  
  /**
   * Returns a function that will execute the supplied function in the
   * supplied object's context, optionally adding any additional
   * supplied parameters to the end of the arguments the function
   * is executed with.
   *
   * @method rbind
   * @param {Function|String} f the function to bind, or a function name
   * to execute on the context object.
   * @param {object} c the execution context.
   * @param {any} args* 0..n arguments to append to the end of
   * arguments collection supplied to the function.
   * @return {function} the wrapped function.
   */
  Y.rbind = function(f, c) {
      var xargs = arguments.length > 2 ? Y.Array(arguments, 2, true) : null;
      return function() {
          var fn = L.isString(f) ? c[f] : f,
              args = (xargs) ?
                  Y.Array(arguments, 0, true).concat(xargs) : arguments;
          return fn.apply(c || fn, args);
      };
  };
  
  
  }, '@VERSION@' ,{requires:['yui-base']});
  YUI.add('features', function(Y) {
  
  var feature_tests = {};
  
  /**
  Contains the core of YUI's feature test architecture.
  @module features
  */
  
  /**
  * Feature detection
  * @class Features
  * @static
  */
  
  Y.mix(Y.namespace('Features'), {
      
      /**
      * Object hash of all registered feature tests
      * @property tests
      * @type Object
      */
      tests: feature_tests,
      
      /**
      * Add a test to the system
      * 
      *   ```
      *   Y.Features.add("load", "1", {});
      *   ```
      * 
      * @method add
      * @param {String} cat The category, right now only 'load' is supported
      * @param {String} name The number sequence of the test, how it's reported in the URL or config: 1, 2, 3
      * @param {Object} o Object containing test properties
      * @param {String} o.name The name of the test
      * @param {Function} o.test The test function to execute, the only argument to the function is the `Y` instance
      * @param {String} o.trigger The module that triggers this test.
      */
      add: function(cat, name, o) {
          feature_tests[cat] = feature_tests[cat] || {};
          feature_tests[cat][name] = o;
      },
      /**
      * Execute all tests of a given category and return the serialized results
      *
      *   ```
      *   caps=1:1;2:1;3:0
      *   ```
      * @method all
      * @param {String} cat The category to execute
      * @param {Array} args The arguments to pass to the test function
      * @return {String} A semi-colon separated string of tests and their success/failure: 1:1;2:1;3:0
      */
      all: function(cat, args) {
          var cat_o = feature_tests[cat],
              // results = {};
              result = [];
          if (cat_o) {
              Y.Object.each(cat_o, function(v, k) {
                  result.push(k + ':' + (Y.Features.test(cat, k, args) ? 1 : 0));
              });
          }
  
          return (result.length) ? result.join(';') : '';
      },
      /**
      * Run a sepecific test and return a Boolean response.
      *
      *   ```
      *   Y.Features.test("load", "1");
      *   ```
      *
      * @method test
      * @param {String} cat The category of the test to run
      * @param {String} name The name of the test to run
      * @param {Array} args The arguments to pass to the test function
      * @return {Boolean} True or false if the test passed/failed.
      */
      test: function(cat, name, args) {
          args = args || [];
          var result, ua, test,
              cat_o = feature_tests[cat],
              feature = cat_o && cat_o[name];
  
          if (!feature) {
          } else {
  
              result = feature.result;
  
              if (Y.Lang.isUndefined(result)) {
  
                  ua = feature.ua;
                  if (ua) {
                      result = (Y.UA[ua]);
                  }
  
                  test = feature.test;
                  if (test && ((!ua) || result)) {
                      result = test.apply(Y, args);
                  }
  
                  feature.result = result;
              }
          }
  
          return result;
      }
  });
  
  // Y.Features.add("load", "1", {});
  // Y.Features.test("load", "1");
  // caps=1:1;2:0;3:1;
  
  /* This file is auto-generated by src/loader/scripts/meta_join.js */
  var add = Y.Features.add;
  // app-transitions-native
  add('load', '0', {
      "name": "app-transitions-native",
      "test": function (Y) {
      var doc  = Y.config.doc,
          node = doc ? doc.documentElement : null;
  
      if (node && node.style) {
          return ('MozTransition' in node.style || 'WebkitTransition' in node.style);
      }
  
      return false;
  },
      "trigger": "app-transitions"
  });
  // autocomplete-list-keys
  add('load', '1', {
      "name": "autocomplete-list-keys",
      "test": function (Y) {
      // Only add keyboard support to autocomplete-list if this doesn't appear to
      // be an iOS or Android-based mobile device.
      //
      // There's currently no feasible way to actually detect whether a device has
      // a hardware keyboard, so this sniff will have to do. It can easily be
      // overridden by manually loading the autocomplete-list-keys module.
      //
      // Worth noting: even though iOS supports bluetooth keyboards, Mobile Safari
      // doesn't fire the keyboard events used by AutoCompleteList, so there's
      // no point loading the -keys module even when a bluetooth keyboard may be
      // available.
      return !(Y.UA.ios || Y.UA.android);
  },
      "trigger": "autocomplete-list"
  });
  // dd-gestures
  add('load', '2', {
      "name": "dd-gestures",
      "test": function(Y) {
      return ((Y.config.win && ("ontouchstart" in Y.config.win)) && !(Y.UA.chrome && Y.UA.chrome < 6));
  },
      "trigger": "dd-drag"
  });
  // dom-style-ie
  add('load', '3', {
      "name": "dom-style-ie",
      "test": function (Y) {
  
      var testFeature = Y.Features.test,
          addFeature = Y.Features.add,
          WINDOW = Y.config.win,
          DOCUMENT = Y.config.doc,
          DOCUMENT_ELEMENT = 'documentElement',
          ret = false;
  
      addFeature('style', 'computedStyle', {
          test: function() {
              return WINDOW && 'getComputedStyle' in WINDOW;
          }
      });
  
      addFeature('style', 'opacity', {
          test: function() {
              return DOCUMENT && 'opacity' in DOCUMENT[DOCUMENT_ELEMENT].style;
          }
      });
  
      ret =  (!testFeature('style', 'opacity') &&
              !testFeature('style', 'computedStyle'));
  
      return ret;
  },
      "trigger": "dom-style"
  });
  // editor-para-ie
  add('load', '4', {
      "name": "editor-para-ie",
      "trigger": "editor-para",
      "ua": "ie",
      "when": "instead"
  });
  // event-base-ie
  add('load', '5', {
      "name": "event-base-ie",
      "test": function(Y) {
      var imp = Y.config.doc && Y.config.doc.implementation;
      return (imp && (!imp.hasFeature('Events', '2.0')));
  },
      "trigger": "node-base"
  });
  // graphics-canvas
  add('load', '6', {
      "name": "graphics-canvas",
      "test": function(Y) {
      var DOCUMENT = Y.config.doc,
          useCanvas = Y.config.defaultGraphicEngine && Y.config.defaultGraphicEngine == "canvas",
  		canvas = DOCUMENT && DOCUMENT.createElement("canvas"),
          svg = (DOCUMENT && DOCUMENT.implementation.hasFeature("http://www.w3.org/TR/SVG11/feature#BasicStructure", "1.1"));
      return (!svg || useCanvas) && (canvas && canvas.getContext && canvas.getContext("2d"));
  },
      "trigger": "graphics"
  });
  // graphics-canvas-default
  add('load', '7', {
      "name": "graphics-canvas-default",
      "test": function(Y) {
      var DOCUMENT = Y.config.doc,
          useCanvas = Y.config.defaultGraphicEngine && Y.config.defaultGraphicEngine == "canvas",
  		canvas = DOCUMENT && DOCUMENT.createElement("canvas"),
          svg = (DOCUMENT && DOCUMENT.implementation.hasFeature("http://www.w3.org/TR/SVG11/feature#BasicStructure", "1.1"));
      return (!svg || useCanvas) && (canvas && canvas.getContext && canvas.getContext("2d"));
  },
      "trigger": "graphics"
  });
  // graphics-svg
  add('load', '8', {
      "name": "graphics-svg",
      "test": function(Y) {
      var DOCUMENT = Y.config.doc,
          useSVG = !Y.config.defaultGraphicEngine || Y.config.defaultGraphicEngine != "canvas",
  		canvas = DOCUMENT && DOCUMENT.createElement("canvas"),
          svg = (DOCUMENT && DOCUMENT.implementation.hasFeature("http://www.w3.org/TR/SVG11/feature#BasicStructure", "1.1"));
      
      return svg && (useSVG || !canvas);
  },
      "trigger": "graphics"
  });
  // graphics-svg-default
  add('load', '9', {
      "name": "graphics-svg-default",
      "test": function(Y) {
      var DOCUMENT = Y.config.doc,
          useSVG = !Y.config.defaultGraphicEngine || Y.config.defaultGraphicEngine != "canvas",
  		canvas = DOCUMENT && DOCUMENT.createElement("canvas"),
          svg = (DOCUMENT && DOCUMENT.implementation.hasFeature("http://www.w3.org/TR/SVG11/feature#BasicStructure", "1.1"));
      
      return svg && (useSVG || !canvas);
  },
      "trigger": "graphics"
  });
  // graphics-vml
  add('load', '10', {
      "name": "graphics-vml",
      "test": function(Y) {
      var DOCUMENT = Y.config.doc,
  		canvas = DOCUMENT && DOCUMENT.createElement("canvas");
      return (DOCUMENT && !DOCUMENT.implementation.hasFeature("http://www.w3.org/TR/SVG11/feature#BasicStructure", "1.1") && (!canvas || !canvas.getContext || !canvas.getContext("2d")));
  },
      "trigger": "graphics"
  });
  // graphics-vml-default
  add('load', '11', {
      "name": "graphics-vml-default",
      "test": function(Y) {
      var DOCUMENT = Y.config.doc,
  		canvas = DOCUMENT && DOCUMENT.createElement("canvas");
      return (DOCUMENT && !DOCUMENT.implementation.hasFeature("http://www.w3.org/TR/SVG11/feature#BasicStructure", "1.1") && (!canvas || !canvas.getContext || !canvas.getContext("2d")));
  },
      "trigger": "graphics"
  });
  // history-hash-ie
  add('load', '12', {
      "name": "history-hash-ie",
      "test": function (Y) {
      var docMode = Y.config.doc && Y.config.doc.documentMode;
  
      return Y.UA.ie && (!('onhashchange' in Y.config.win) ||
              !docMode || docMode < 8);
  },
      "trigger": "history-hash"
  });
  // io-nodejs
  add('load', '13', {
      "name": "io-nodejs",
      "trigger": "io-base",
      "ua": "nodejs"
  });
  // scrollview-base-ie
  add('load', '14', {
      "name": "scrollview-base-ie",
      "trigger": "scrollview-base",
      "ua": "ie"
  });
  // selector-css2
  add('load', '15', {
      "name": "selector-css2",
      "test": function (Y) {
      var DOCUMENT = Y.config.doc,
          ret = DOCUMENT && !('querySelectorAll' in DOCUMENT);
  
      return ret;
  },
      "trigger": "selector"
  });
  // transition-timer
  add('load', '16', {
      "name": "transition-timer",
      "test": function (Y) {
      var DOCUMENT = Y.config.doc,
          node = (DOCUMENT) ? DOCUMENT.documentElement: null,
          ret = true;
  
      if (node && node.style) {
          ret = !('MozTransition' in node.style || 'WebkitTransition' in node.style);
      } 
  
      return ret;
  },
      "trigger": "transition"
  });
  // widget-base-ie
  add('load', '17', {
      "name": "widget-base-ie",
      "trigger": "widget-base",
      "ua": "ie"
  });
  
  
  }, '@VERSION@' ,{requires:['yui-base']});
  YUI.add('dom-core', function(Y) {
  
  var NODE_TYPE = 'nodeType',
      OWNER_DOCUMENT = 'ownerDocument',
      DOCUMENT_ELEMENT = 'documentElement',
      DEFAULT_VIEW = 'defaultView',
      PARENT_WINDOW = 'parentWindow',
      TAG_NAME = 'tagName',
      PARENT_NODE = 'parentNode',
      PREVIOUS_SIBLING = 'previousSibling',
      NEXT_SIBLING = 'nextSibling',
      CONTAINS = 'contains',
      COMPARE_DOCUMENT_POSITION = 'compareDocumentPosition',
      EMPTY_ARRAY = [],
  
  /** 
   * The DOM utility provides a cross-browser abtraction layer
   * normalizing DOM tasks, and adds extra helper functionality
   * for other common tasks. 
   * @module dom
   * @main dom
   * @submodule dom-base
   * @for DOM
   *
   */
  
  /**
   * Provides DOM helper methods.
   * @class DOM
   *
   */
      
  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) {
          // handle dupe IDs and IE name collision
          return Y_DOM.allById(id, doc)[0] || null;
      },
  
      getId: function(node) {
          var id;
          // HTMLElement returned from FORM when INPUT name === "id"
          // IE < 8: HTMLCollection returned when INPUT id === "id"
          // via both getAttribute and form.id 
          if (node.id && !node.id.tagName && !node.id.item) {
              id = node.id;
          } else if (node.attributes && node.attributes.id) {
              id = node.attributes.id.value;
          }
  
          return id;
      },
  
      setId: function(node, id) {
          if (node.setAttribute) {
              node.setAttribute('id', id);
          } else {
              node.id = id;
          }
      },
  
      /*
       * Finds the ancestor of the element.
       * @method ancestor
       * @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} testSelf optional Whether or not to include the element in the scan 
       * @return {HTMLElement | null} The matching DOM node or null if none found. 
       */
      ancestor: function(element, fn, testSelf, stopFn) {
          var ret = null;
          if (testSelf) {
              ret = (!fn || fn(element)) ? element : null;
  
          }
          return ret || Y_DOM.elementByAxis(element, PARENT_NODE, fn, null, stopFn);
      },
  
      /*
       * Finds the ancestors of the element.
       * @method ancestors
       * @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, all ancestors are returned.
       * @param {Boolean} testSelf optional Whether or not to include the element in the scan 
       * @return {Array} An array containing all matching DOM nodes.
       */
      ancestors: function(element, fn, testSelf, stopFn) {
          var ancestor = element,
              ret = [];
  
          while ((ancestor = Y_DOM.ancestor(ancestor, fn, testSelf, stopFn))) {
              testSelf = false;
              if (ancestor) {
                  ret.unshift(ancestor);
  
                  if (stopFn && stopFn(ancestor)) {
                      return ret;
                  }
              }
          }
  
          return ret;
      },
  
      /**
       * 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, stopAt) {
          while (element && (element = element[axis])) { // NOTE: assignment
                  if ( (all || element[TAG_NAME]) && (!fn || fn(element)) ) {
                      return element;
                  }
  
                  if (stopAt && stopAt(element)) {
                      return null;
                  }
          }
          return null;
      },
  
      /**
       * 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) {
          var ret = false,
              rootNode;
  
          if (element && element.nodeType) {
              (doc) || (doc = element[OWNER_DOCUMENT]);
  
              rootNode = doc[DOCUMENT_ELEMENT];
  
              // contains only works with HTML_ELEMENT
              if (rootNode && rootNode.contains && element.tagName) {
                  ret = rootNode.contains(element);
              } else {
                  ret = Y_DOM.contains(rootNode, element);
              }
          }
  
          return ret;
  
      },
  
     allById: function(id, root) {
          root = root || Y.config.doc;
          var nodes = [],
              ret = [],
              i,
              node;
  
          if (root.querySelectorAll) {
              ret = root.querySelectorAll('[id="' + id + '"]');
          } else if (root.all) {
              nodes = root.all(id);
  
              if (nodes) {
                  // root.all may return HTMLElement or HTMLCollection.
                  // some elements are also HTMLCollection (FORM, SELECT).
                  if (nodes.nodeName) {
                      if (nodes.id === id) { // avoid false positive on name
                          ret.push(nodes);
                          nodes = EMPTY_ARRAY; // done, no need to filter
                      } else { //  prep for filtering
                          nodes = [nodes];
                      }
                  }
  
                  if (nodes.length) {
                      // filter out matches on node.name
                      // and element.id as reference to element with id === 'id'
                      for (i = 0; node = nodes[i++];) {
                          if (node.id === id  || 
                                  (node.attributes && node.attributes.id &&
                                  node.attributes.id.value === id)) { 
                              ret.push(node);
                          }
                      }
                  }
              }
          } else {
              ret = [Y_DOM._getDoc(root).getElementById(id)];
          }
      
          return ret;
     },
  
  
      isWindow: function(obj) {
          return !!(obj && obj.alert && obj.document);
      },
  
      _removeChildNodes: function(node) {
          while (node.firstChild) {
              node.removeChild(node.firstChild);
          }
      },
  
      siblings: function(node, fn) {
          var nodes = [],
              sibling = node;
  
          while ((sibling = sibling[PREVIOUS_SIBLING])) {
              if (sibling[TAG_NAME] && (!fn || fn(sibling))) {
                  nodes.unshift(sibling);
              }
          }
  
          sibling = node;
          while ((sibling = sibling[NEXT_SIBLING])) {
              if (sibling[TAG_NAME] && (!fn || fn(sibling))) {
                  nodes.push(sibling);
              }
          }
  
          return nodes;
      },
  
      /**
       * 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) {
          var doc = Y.config.doc;
          if (element) {
              doc = (element[NODE_TYPE] === 9) ? element : // element === document
                  element[OWNER_DOCUMENT] || // element === DOM node
                  element.document || // element === window
                  Y.config.doc; // default
          }
  
          return doc;
      },
  
      /**
       * 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;
      },
  
      _batch: function(nodes, fn, arg1, arg2, arg3, etc) {
          fn = (typeof fn === 'string') ? Y_DOM[fn] : fn;
          var result,
              i = 0,
              node,
              ret;
  
          if (fn && nodes) {
              while ((node = nodes[i++])) {
                  result = result = fn.call(Y_DOM, node, arg1, arg2, arg3, etc);
                  if (typeof result !== 'undefined') {
                      (ret) || (ret = []);
                      ret.push(result);
                  }
              }
          }
  
          return (typeof ret !== 'undefined') ? ret : nodes;
      },
  
      generateID: function(el) {
          var id = el.id;
  
          if (!id) {
              id = Y.stamp(el);
              el.id = id; 
          }   
  
          return id; 
      }
  };
  
  
  Y.DOM = Y_DOM;
  
  
  }, '@VERSION@' ,{requires:['oop','features']});
  YUI.add('dom-base', function(Y) {
  
  /**
  * @for DOM
  * @module dom
  */
  var documentElement = Y.config.doc.documentElement,
      Y_DOM = Y.DOM,
      TAG_NAME = 'tagName',
      OWNER_DOCUMENT = 'ownerDocument',
      EMPTY_STRING = '',
      addFeature = Y.Features.add,
      testFeature = Y.Features.test;
  
  Y.mix(Y_DOM, {
      /**
       * 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: (documentElement.textContent !== undefined) ?
          function(element) {
              var ret = '';
              if (element) {
                  ret = element.textContent;
              }
              return ret || '';
          } : function(element) {
              var ret = '';
              if (element) {
                  ret = element.innerText || element.nodeValue; // might be a textNode
              }
              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: (documentElement.textContent !== undefined) ?
          function(element, content) {
              if (element) {
                  element.textContent = content;
              }
          } : function(element, content) {
              if ('innerText' in element) {
                  element.innerText = content;
              } else if ('nodeValue' in element) {
                  element.nodeValue = content;
              }
      },
  
      CUSTOM_ATTRIBUTES: (!documentElement.hasAttribute) ? { // IE < 8
          'for': 'htmlFor',
          'class': 'className'
      } : { // w3c
          'htmlFor': 'for',
          'className': 'class'
      },
  
      /**
       * Provides a normalized attribute interface. 
       * @method setAttribute
       * @param {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, ieAttr) {
          if (el && attr && el.setAttribute) {
              attr = Y_DOM.CUSTOM_ATTRIBUTES[attr] || attr;
              el.setAttribute(attr, val, ieAttr);
          }
      },
  
  
      /**
       * Provides a normalized attribute interface. 
       * @method getAttribute
       * @param {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, ieAttr) {
          ieAttr = (ieAttr !== undefined) ? ieAttr : 2;
          var ret = '';
          if (el && attr && el.getAttribute) {
              attr = Y_DOM.CUSTOM_ATTRIBUTES[attr] || attr;
              ret = el.getAttribute(attr, ieAttr);
  
              if (ret === null) {
                  ret = ''; // per DOM spec
              }
          }
          return ret;
      },
  
      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;
              }
          }
  
          // workaround for IE8 JSON stringify bug
          // which converts empty string values to null
          if (ret === EMPTY_STRING) {
              ret = EMPTY_STRING; // for real
          }
  
          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;
              }
          }
      },
  
      creators: {}
  });
  
  addFeature('value-set', 'select', {
      test: function() {
          var node = Y.config.doc.createElement('select');
          node.innerHTML = '<option>1</option><option>2</option>';
          node.value = '2';
          return (node.value && node.value === '2');
      }
  });
  
  if (!testFeature('value-set', 'select')) {
      Y_DOM.VALUE_SETTERS.select = function(node, val) {
          for (var i = 0, options = node.getElementsByTagName('option'), option;
                  option = options[i++];) {
              if (Y_DOM.getValue(option) === val) {
                  option.selected = true;
                  //Y_DOM.setAttribute(option, 'selected', 'selected');
                  break;
              }
          }
      }
  }
  
  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;
      }
  });
  
  
  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 && options.length) {
              // TODO: implement multipe select
              if (node.multiple) {
              } else if (node.selectedIndex > -1) {
                  val = Y_DOM.getValue(options[node.selectedIndex]);
              }
          }
  
          return val;
      }
  });
  var addClass, hasClass, removeClass;
  
  Y.mix(Y.DOM, {
      /**
       * Determines whether a DOM element has the given className.
       * @method hasClass
       * @for DOM
       * @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         
       * @for DOM
       * @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         
       * @for DOM
       * @param {HTMLElement} element The DOM element. 
       * @param {String} className the class name to remove from the class attribute
       */
      removeClass: function(node, className) {
          if (className && hasClass(node, className)) {
              node.className = Y.Lang.trim(node.className.replace(Y.DOM._getRegExp('(?:^|\\s+)' +
                              className + '(?:\\s+|$)'), ' '));
  
              if ( hasClass(node, className) ) { // in case of multiple adjacent
                  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  
       * @for DOM
       * @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) {
          removeClass(node, oldC); // remove first in case oldC === newC
          addClass(node, newC);
      },
  
      /**
       * If the className exists on the node it is removed, if it doesn't exist it is added.
       * @method toggleClass  
       * @for DOM
       * @param {HTMLElement} element The DOM element
       * @param {String} className the class name to be toggled
       * @param {Boolean} addClass optional boolean to indicate whether class
       * should be added or removed regardless of current state
       */
      toggleClass: function(node, className, force) {
          var add = (force !== undefined) ? force :
                  !(hasClass(node, className));
  
          if (add) {
              addClass(node, className);
          } else {
              removeClass(node, className);
          }
      }
  });
  
  hasClass = Y.DOM.hasClass;
  removeClass = Y.DOM.removeClass;
  addClass = Y.DOM.addClass;
  
  var re_tag = /<([a-z]+)/i,
  
      Y_DOM = Y.DOM,
  
      addFeature = Y.Features.add,
      testFeature = Y.Features.test,
  
      creators = {},
  
      createFromDIV = function(html, tag) {
          var div = Y.config.doc.createElement('div'),
              ret = true;
  
          div.innerHTML = html;
          if (!div.firstChild || div.firstChild.tagName !== tag.toUpperCase()) {
              ret = false;
          }
  
          return ret;
      },
  
      re_tbody = /(?:\/(?:thead|tfoot|tbody|caption|col|colgroup)>)+\s*<tbody/,
  
      TABLE_OPEN = '<table>',
      TABLE_CLOSE = '</table>';
  
  Y.mix(Y.DOM, {
      _fragClones: {},
  
      _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;
      },
  
      _children: function(node, tag) {
              var i = 0,
              children = node.children,
              childNodes,
              hasComments,
              child;
  
          if (children && children.tags) { // use tags filter when possible
              if (tag) {
                  children = node.children.tags(tag);
              } else { // IE leaks comments into children
                  hasComments = children.tags('!').length;
              }
          }
          
          if (!children || (!children.tags && tag) || hasComments) {
              childNodes = children || node.childNodes;
              children = [];
              while ((child = childNodes[i++])) {
                  if (child.nodeType === 1) {
                      if (!tag || tag === child.tagName) {
                          children.push(child);
                      }
                  }
              }
          }
  
          return children || [];
      },
  
      /**
       * 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 
       * @return {HTMLElement|DocumentFragment} returns a single HTMLElement 
       * when creating one node, and a documentFragment when creating
       * multiple nodes.
       */
      create: function(html, doc) {
          if (typeof html === 'string') {
              html = Y.Lang.trim(html); // match IE which trims whitespace from innerHTML
  
          }
  
          doc = doc || Y.config.doc;
          var m = re_tag.exec(html),
              create = Y_DOM._create,
              custom = creators,
              ret = null,
              creator,
              tag, nodes;
  
          if (html != undefined) { // not undefined or null
              if (m && m[1]) {
                  creator = custom[m[1].toLowerCase()];
                  if (typeof creator === 'function') {
                      create = creator; 
                  } else {
                      tag = creator;
                  }
              }
  
              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 if (nodes[0] && nodes[0].className === 'yui3-big-dummy') { // using dummy node to preserve some attributes (e.g. OPTION not selected)
                  if (nodes.length === 2) {
                      ret = nodes[0].nextSibling;
                  } else {
                      nodes[0].parentNode.removeChild(nodes[0]); 
                      ret = Y_DOM._nl2frag(nodes, doc);
                  }
              } else { // return multiple nodes as a fragment
                   ret = Y_DOM._nl2frag(nodes, doc);
              }
  
          }
  
          return ret;
      },
  
      _nl2frag: function(nodes, doc) {
          var ret = null,
              i, len;
  
          if (nodes && (nodes.push || nodes.item) && nodes[0]) {
              doc = doc || nodes[0].ownerDocument; 
              ret = doc.createDocumentFragment();
  
              if (nodes.item) { // convert live list to static array
                  nodes = Y.Array(nodes, 0, true);
              }
  
              for (i = 0, len = nodes.length; i < len; i++) {
                  ret.appendChild(nodes[i]); 
              }
          } // else inline with log for minification
          return ret;
      },
  
      /**
       * Inserts content in a node at the given location 
       * @method addHTML
       * @param {HTMLElement} node The node to insert into
       * @param {HTMLElement | Array | HTMLCollection} content The content to be inserted 
       * @param {HTMLElement} where Where to insert the content
       * If no "where" is given, content is appended to the node
       * Possible values for "where"
       * <dl>
       * <dt>HTMLElement</dt>
       * <dd>The element to insert before</dd>
       * <dt>"replace"</dt>
       * <dd>Replaces the existing HTML</dd>
       * <dt>"before"</dt>
       * <dd>Inserts before the existing HTML</dd>
       * <dt>"before"</dt>
       * <dd>Inserts content before the node</dd>
       * <dt>"after"</dt>
       * <dd>Inserts content after the node</dd>
       * </dl>
       */
      addHTML: function(node, content, where) {
          var nodeParent = node.parentNode,
              i = 0,
              item,
              ret = content,
              newNode;
              
  
          if (content != undefined) { // not null or undefined (maybe 0)
              if (content.nodeType) { // DOM node, just add it
                  newNode = content;
              } else if (typeof content == 'string' || typeof content == 'number') {
                  ret = newNode = Y_DOM.create(content);
              } else if (content[0] && content[0].nodeType) { // array or collection 
                  newNode = Y.config.doc.createDocumentFragment();
                  while ((item = content[i++])) {
                      newNode.appendChild(item); // append to fragment for insertion
                  }
              }
          }
  
          if (where) {
              if (newNode && where.parentNode) { // insert regardless of relationship to node
                  where.parentNode.insertBefore(newNode, where);
              } else {
                  switch (where) {
                      case 'replace':
                          while (node.firstChild) {
                              node.removeChild(node.firstChild);
                          }
                          if (newNode) { // allow empty content to clear node
                              node.appendChild(newNode);
                          }
                          break;
                      case 'before':
                          if (newNode) {
                              nodeParent.insertBefore(newNode, node);
                          }
                          break;
                      case 'after':
                          if (newNode) {
                              if (node.nextSibling) { // IE errors if refNode is null
                                  nodeParent.insertBefore(newNode, node.nextSibling);
                              } else {
                                  nodeParent.appendChild(newNode);
                              }
                          }
                          break;
                      default:
                          if (newNode) {
                              node.appendChild(newNode);
                          }
                  }
              }
          } else if (newNode) {
              node.appendChild(newNode);
          }
  
          return ret;
      },
  
      wrap: function(node, html) {
          var parent = (html && html.nodeType) ? html : Y.DOM.create(html),
              nodes = parent.getElementsByTagName('*');
  
          if (nodes.length) {
              parent = nodes[nodes.length - 1];
          }
  
          if (node.parentNode) { 
              node.parentNode.replaceChild(parent, node);
          }
          parent.appendChild(node);
      },
  
      unwrap: function(node) {
          var parent = node.parentNode,
              lastChild = parent.lastChild,
              next = node,
              grandparent;
  
          if (parent) {
              grandparent = parent.parentNode;
              if (grandparent) {
                  node = parent.firstChild;
                  while (node !== lastChild) {
                      next = node.nextSibling;
                      grandparent.insertBefore(node, parent);
                      node = next;
                  }
                  grandparent.replaceChild(lastChild, parent);
              } else {
                  parent.removeChild(node);
              }
          }
      }
  });
  
  addFeature('innerhtml', 'table', {
      test: function() {
          var node = Y.config.doc.createElement('table');
          try {
              node.innerHTML = '<tbody></tbody>';
          } catch(e) {
              return false;
          }
          return (node.firstChild && node.firstChild.nodeName === 'TBODY');
      }
  });
  
  addFeature('innerhtml-div', 'tr', {
      test: function() {
          return createFromDIV('<tr></tr>', 'tr');
      }
  });
  
  addFeature('innerhtml-div', 'script', {
      test: function() {
          return createFromDIV('<script></script>', 'script');
      }
  });
  
  if (!testFeature('innerhtml', 'table')) {
      // TODO: thead/tfoot with nested tbody
          // IE adds TBODY when creating TABLE elements (which may share this impl)
      creators.tbody = function(html, doc) {
          var frag = Y_DOM.create(TABLE_OPEN + html + TABLE_CLOSE, doc),
              tb = Y.DOM._children(frag, 'tbody')[0];
  
          if (frag.children.length > 1 && tb && !re_tbody.test(html)) {
              tb.parentNode.removeChild(tb); // strip extraneous tbody
          }
          return frag;
      };
  }
  
  if (!testFeature('innerhtml-div', 'script')) {
      creators.script = function(html, doc) {
          var frag = doc.createElement('div');
  
          frag.innerHTML = '-' + html;
          frag.removeChild(frag.firstChild);
          return frag;
      }
  
      creators.link = creators.style = creators.script;
  }
  
  if (!testFeature('innerhtml-div', 'tr')) {
      Y.mix(creators, {
          option: function(html, doc) {
              return Y_DOM.create('<select><option class="yui3-big-dummy" selected></option>' + html + '</select>', doc);
          },
  
          tr: function(html, doc) {
              return Y_DOM.create('<tbody>' + html + '</tbody>', doc);
          },
  
          td: function(html, doc) {
              return Y_DOM.create('<tr>' + html + '</tr>', doc);
          }, 
  
          col: function(html, doc) {
              return Y_DOM.create('<colgroup>' + html + '</colgroup>', doc);
          }, 
  
          tbody: 'table'
      });
  
      Y.mix(creators, {
          legend: 'fieldset',
          th: creators.td,
          thead: creators.tbody,
          tfoot: creators.tbody,
          caption: creators.tbody,
          colgroup: creators.tbody,
          optgroup: creators.option
      });
  }
  
  Y_DOM.creators = creators;
  Y.mix(Y.DOM, {
      /**
       * Sets the width of the element to the given size, regardless
       * of box model, border, padding, etc.
       * @method setWidth
       * @param {HTMLElement} element The DOM element. 
       * @param {String|Number} size The pixel height to size to
       */
  
      setWidth: function(node, size) {
          Y.DOM._setSize(node, 'width', size);
      },
  
      /**
       * Sets the height of the element to the given size, regardless
       * of box model, border, padding, etc.
       * @method setHeight
       * @param {HTMLElement} element The DOM element. 
       * @param {String|Number} size The pixel height to size to
       */
  
      setHeight: function(node, size) {
          Y.DOM._setSize(node, 'height', size);
      },
  
      _setSize: function(node, prop, val) {
          val = (val > 0) ? val : 0;
          var size = 0;
  
          node.style[prop] = val + 'px';
          size = (prop === 'height') ? node.offsetHeight : node.offsetWidth;
  
          if (size > val) {
              val = val - (size - val);
  
              if (val < 0) {
                  val = 0;
              }
  
              node.style[prop] = val + 'px';
          }
      }
  });
  
  
  }, '@VERSION@' ,{requires:['dom-core']});
  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',
      GET_BOUNDING_CLIENT_RECT = 'getBoundingClientRect',
  
      WINDOW = Y.config.win,
      DOCUMENT = Y.config.doc,
      UNDEFINED = undefined,
  
      Y_DOM = Y.DOM,
  
      TRANSFORM = 'transform',
      VENDOR_TRANSFORM = [
          'WebkitTransform',
          'MozTransform',
          'OTransform'
      ],
  
      re_color = /color$/i,
      re_unit = /width|height|top|left|right|bottom|margin|padding/i;
  
  Y.Array.each(VENDOR_TRANSFORM, function(val) {
      if (val in DOCUMENT[DOCUMENT_ELEMENT].style) {
          TRANSFORM = val;
      }
  });
  
  Y.mix(Y_DOM, {
      DEFAULT_UNIT: 'px',
  
      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 unsetting
                  val = '';
              } else if (!isNaN(new Number(val)) && re_unit.test(att)) { // number values may need a unit
                  val += Y_DOM.DEFAULT_UNIT;
              }
  
              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];
                  }
              } else if (att === '') { // unset inline styles
                  att = 'cssText';
                  val = '';
              }
              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, style) {
          style = style || node.style;
          var 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],
              computed;
  
          if (node[STYLE] && doc[DEFAULT_VIEW] && doc[DEFAULT_VIEW][GET_COMPUTED_STYLE]) {
              computed = doc[DEFAULT_VIEW][GET_COMPUTED_STYLE](node, null);
              if (computed) { // FF may be null in some cases (ticket #2530548)
                  val = computed[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.DOM._getAttrOffset = function(node, attr) {
      var val = Y.DOM[GET_COMPUTED_STYLE](node, attr),
          offsetParent = node.offsetParent,
          position,
          parentOffset,
          offset;
  
      if (val === 'auto') {
          position = Y.DOM.getStyle(node, 'position');
          if (position === 'static' || position === 'relative') {
              val = 0;    
          } else if (offsetParent && offsetParent[GET_BOUNDING_CLIENT_RECT]) {
              parentOffset = offsetParent[GET_BOUNDING_CLIENT_RECT]()[attr];
              offset = node[GET_BOUNDING_CLIENT_RECT]()[attr];
              if (attr === 'left' || attr === 'top') {
                  val = offset - parentOffset;
              } else {
                  val = parentOffset - node[GET_BOUNDING_CLIENT_RECT]()[attr];
              }
          }
      }
  
      return val;
  };
  
  Y.DOM._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;
  
  };
  
  Y_DOM.CUSTOM_STYLES.transform = {
      set: function(node, val, style) {
          style[TRANSFORM] = val;
      },
  
      get: function(node, style) {
          return Y_DOM[GET_COMPUTED_STYLE](node, TRANSFORM);
      }
  };
  
  
  })(Y);
  (function(Y) {
  var 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)) {
              val = [
                  Number(RE.$1).toString(16),
                  Number(RE.$2).toString(16),
                  Number(RE.$3).toString(16)
              ];
  
              for (var i = 0; i < val.length; i++) {
                  if (val[i].length < 2) {
                      val[i] = '0' + val[i];
                  }
              }
  
              val = val.join('');
          }
  
          if (val.length < 6) {
              val = val.replace(Y.Color.re_hex3, '$1$1');
          }
  
          if (val !== 'transparent' && val.indexOf('#') < 0) {
              val = '#' + val;
          }
  
          return val.toUpperCase();
      }
  };
  })(Y);
  
  
  
  }, '@VERSION@' ,{requires:['dom-base']});
  YUI.add('dom-style-ie', function(Y) {
  
  (function(Y) {
  var HAS_LAYOUT = 'hasLayout',
      PX = 'px',
      FILTER = 'filter',
      FILTERS = 'filters',
      OPACITY = 'opacity',
      AUTO = 'auto',
  
      BORDER_WIDTH = 'borderWidth',
      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 = Y.config.doc.documentElement,
  
      testFeature = Y.Features.test,
      addFeature = Y.Features.add,
  
      // TODO: unit-less lineHeight (e.g. 1.22)
      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,
  
      isIE8 = (Y.UA.ie >= 8),
  
      _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 && Y.DOM.CUSTOM_STYLES[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;
          },
  
          sizeOffsets: {
              width: ['Left', 'Right'],
              height: ['Top', 'Bottom'],
              top: ['Top'],
              bottom: ['Bottom']
          },
  
          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.
                  sizeOffsets = ComputedStyle.sizeOffsets[prop], 
                  mode = el.ownerDocument.compatMode,
                  value = '';
  
              // IE pixelWidth incorrect for percent
              // manually compute by subtracting padding and border from offset size
              // NOTE: clientWidth/Height (size minus border) is 0 when current === AUTO so offsetHeight is used
              // reverting to auto from auto causes position stacking issues (old impl)
              if (current === AUTO || current.indexOf('%') > -1) {
                  value = el['offset' + capped];
  
                  if (mode !== 'BackCompat') {
                      if (sizeOffsets[0]) {
                          value -= ComputedStyle.getPixel(el, 'padding' + sizeOffsets[0]);
                          value -= ComputedStyle.getBorderWidth(el, 'border' + sizeOffsets[0] + 'Width', 1);
                      }
  
                      if (sizeOffsets[1]) {
                          value -= ComputedStyle.getPixel(el, 'padding' + sizeOffsets[1]);
                          value -= ComputedStyle.getBorderWidth(el, 'border' + sizeOffsets[1] + 'Width', 1);
                      }
                  }
  
              } else { // use style.pixelWidth, etc. to convert to pixels
                  // need to map style.width to currentStyle (no currentStyle.pixelWidth)
                  if (!el.style[pixel] && !el.style[prop]) {
                      el.style[prop] = current;
                  }
                  value = el.style[pixel];
                  
              }
              return value + PX;
          },
  
          borderMap: {
              thin: (isIE8) ? '1px' : '2px',
              medium: (isIE8) ? '3px': '4px', 
              thick: (isIE8) ? '5px' : '6px'
          },
  
          getBorderWidth: function(el, property, omitUnit) {
              var unit = omitUnit ? '' : PX,
                  current = el.currentStyle[property];
  
              if (current.indexOf(PX) < 0) { // look up keywords if a border exists
                  if (ComputedStyle.borderMap[current] &&
                          el.currentStyle.borderStyle !== 'none') {
                      current = ComputedStyle.borderMap[current];
                  } else { // otherwise no border (default is "medium")
                      current = 0;
                  }
              }
              return (omitUnit) ? parseFloat(current) : current;
          },
  
          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 = {};
  
  addFeature('style', 'computedStyle', {
      test: function() {
          return 'getComputedStyle' in Y.config.win;
      }
  });
  
  addFeature('style', 'opacity', {
      test: function() {
          return 'opacity' in documentElement.style;
      }
  });
  
  addFeature('style', 'filter', {
      test: function() {
          return 'filters' in documentElement;
      }
  });
  
  // use alpha filter for IE opacity
  if (!testFeature('style', 'opacity') && testFeature('style', 'filter')) {
      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) {
                  }
              }
              return val / 100;
          },
  
          set: function(node, val, style) {
              var current,
                  styleObj = _getStyleObj(node),
                  currentFilter = styleObj[FILTER];
  
              style = style || node.style;
              if (val === '') { // normalize inline style behavior
                  current = (OPACITY in styleObj) ? styleObj[OPACITY] : 1; // revert to original opacity
                  val = current;
              }
  
              if (typeof currentFilter == 'string') { // in case not appended
                  style[FILTER] = currentFilter.replace(/alpha([^)]*\))/gi, '') +
                          ((val < 1) ? 'alpha(' + OPACITY + '=' + val * 100 + ')' : '');
  
                  if (!style[FILTER]) {
                      style.removeAttribute(FILTER);
                  }
  
                  if (!styleObj[HAS_LAYOUT]) {
                      style.zoom = 1; // needs layout 
                  }
              }
          }
      };
  }
  
  try {
      Y.config.doc.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) {
              var floatVal = parseFloat(val);
              if (floatVal >= 0 || val === 'auto' || val === '') {
                  style.height = val;
              } else {
              }
          }
      };
  
      Y.DOM.CUSTOM_STYLES.width = {
          set: function(node, val, style) {
              var floatVal = parseFloat(val);
              if (floatVal >= 0 || val === 'auto' || val === '') {
                  style.width = val;
              } else {
              }
          }
      };
  }
  
  if (!testFeature('style', 'computedStyle')) {
      // TODO: top, right, bottom, left
      IEComputed[WIDTH] = IEComputed[HEIGHT] = ComputedStyle.getOffset;
  
      IEComputed.color = IEComputed.backgroundColor = ComputedStyle.getColor;
  
      IEComputed[BORDER_WIDTH] = 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;
  
      Y.DOM[GET_COMPUTED_STYLE] = ComputedStyle.get; 
  
      Y.namespace('DOM.IE');
      Y.DOM.IE.COMPUTED = IEComputed;
      Y.DOM.IE.ComputedStyle = ComputedStyle;
  }
  
  })(Y);
  
  
  }, '@VERSION@' ,{requires:['dom-style']});
  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',
  
      Y_DOM = Y.DOM,
  
      // TODO: how about thead/tbody/tfoot/tr?
      // TODO: does caption matter?
      RE_TABLE = /^t(?:able|d|h)$/i,
  
      SCROLL_NODE;
  
  if (Y.UA.ie) {
      if (Y.config.doc[COMPAT_MODE] !== 'BackCompat') {
          SCROLL_NODE = DOCUMENT_ELEMENT; 
      } else {
          SCROLL_NODE = 'body';
      }
  }
  
  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;
          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;
          return w;
      },
  
      /**
       * Document height 
       * @method docHeight
       * @return {Number} The current height of the document.
       */
      docHeight:  function(node) {
          var h = Y_DOM._getDocSize(node).height;
          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;
          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, doc) {
          doc = doc || (node) ? Y_DOM._getDoc(node) : Y.config.doc; // perf optimization
          var dv = doc.defaultView,
              pageOffset = (dv) ? dv.pageXOffset : 0;
          return Math.max(doc[DOCUMENT_ELEMENT].scrollLeft, doc.body.scrollLeft, pageOffset);
      },
  
      /**
       * Amount page has been scroll vertically 
       * @method docScrollY
       * @return {Number} The current amount the screen is scrolled vertically.
       */
      docScrollY:  function(node, doc) {
          doc = doc || (node) ? Y_DOM._getDoc(node) : Y.config.doc; // perf optimization
          var dv = doc.defaultView,
              pageOffset = (dv) ? dv.pageYOffset : 0;
          return Math.max(doc[DOCUMENT_ELEMENT].scrollTop, doc.body.scrollTop, pageOffset);
      },
  
      /**
       * 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 (Y.config.doc[DOCUMENT_ELEMENT][GET_BOUNDING_CLIENT_RECT]) {
              return function(node) {
                  var xy = null,
                      scrollLeft,
                      scrollTop,
                      mode,
                      box,
                      offX,
                      offY,
                      doc,
                      win,
                      inDoc,
                      rootNode;
  
                  if (node && node.tagName) {
                      doc = node.ownerDocument;
                      mode = doc[COMPAT_MODE];
  
                      if (mode !== _BACK_COMPAT) {
                          rootNode = doc[DOCUMENT_ELEMENT];
                      } else {
                          rootNode = doc.body;
                      }
  
                      // inline inDoc check for perf
                      if (rootNode.contains) {
                          inDoc = rootNode.contains(node); 
                      } else {
                          inDoc = Y.DOM.contains(rootNode, node);
                      }
  
                      if (inDoc) {
                          win = doc.defaultView;
  
                          // inline scroll calc for perf
                          if (win && 'pageXOffset' in win) {
                              scrollLeft = win.pageXOffset;
                              scrollTop = win.pageYOffset;
                          } else {
                              scrollLeft = (SCROLL_NODE) ? doc[SCROLL_NODE].scrollLeft : Y_DOM.docScrollX(node, doc);
                              scrollTop = (SCROLL_NODE) ? doc[SCROLL_NODE].scrollTop : Y_DOM.docScrollY(node, doc);
                          }
  
                          if (Y.UA.ie) { // IE < 8, quirks, or compatMode
                              if (!doc.documentMode || doc.documentMode < 8 || mode === _BACK_COMPAT) {
                                  offX = rootNode.clientLeft;
                                  offY = rootNode.clientTop;
                              }
                          }
                          box = node[GET_BOUNDING_CLIENT_RECT]();
                          xy = [box.left, box.top];
  
                          if (offX || offY) {
                                  xy[0] -= offX;
                                  xy[1] -= offY;
                              
                          }
                          if ((scrollTop || scrollLeft)) {
                              if (!Y.UA.ios || (Y.UA.ios >= 4.2)) {
                                  xy[0] += scrollLeft;
                                  xy[1] += scrollTop;
                              }
                              
                          }
                      } else {
                          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,
                      doc,
                      parentNode,
                      bCheck,
                      scrollTop,
                      scrollLeft;
  
                  if (node) {
                      if (Y_DOM.inDoc(node)) {
                          xy = [node.offsetLeft, node.offsetTop];
                          doc = node.ownerDocument;
                          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, doc);
                              xy[1] += Y_DOM.docScrollY(node, doc);
  
                          } else {
                              //Fix FIXED position -- add scrollbars
                              xy[0] += Y_DOM.docScrollX(node, doc);
                              xy[1] += Y_DOM.docScrollY(node, doc);
                          }
                      } else {
                          xy = Y_DOM._getOffset(node);
                      }
                  }
  
                  return xy;                
              };
          }
      }(),// NOTE: Executing for loadtime branching
  
      /**
      Gets the width of vertical scrollbars on overflowed containers in the body
      content.
  
      @method getScrollbarWidth
      @return {Number} Pixel width of a scrollbar in the current browser
      **/
      getScrollbarWidth: Y.cached(function () {
          var doc      = Y.config.doc,
              testNode = doc.createElement('div'),
              body     = doc.getElementsByTagName('body')[0],
              // 0.1 because cached doesn't support falsy refetch values
              width    = 0.1;
              
          if (body) {
              testNode.style.cssText = "position:absolute;visibility:hidden;overflow:scroll;width:20px;";
              testNode.appendChild(doc.createElement('p')).style.height = '1px';
              body.insertBefore(testNode, body.firstChild);
              width = testNode.offsetWidth - testNode.clientWidth;
  
              body.removeChild(testNode);
          }
  
          return width;
      }, null, 0.1),
  
      /**
       * 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 {Number} 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 {Number} 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); 
                  }
              }
            
          } else {
          }
      },
  
      /**
       * 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 {Number} 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 {Number} y The Y values for new position (coordinates are page-based)
       */
      setY: function(node, y) {
          return Y_DOM.setXY(node, [null, y]);
      },
  
      /**
       * @method swapXY
       * @description Swap the xy position with another node
       * @param {Node} node The node to swap with
       * @param {Node} otherNode The other node to swap with
       * @return {Node}
       */
      swapXY: function(node, otherNode) {
          var xy = Y_DOM.getXY(node);
          Y_DOM.setXY(node, Y_DOM.getXY(otherNode));
          Y_DOM.setXY(otherNode, xy);
      },
  
      _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, doc) {
          doc  = doc || (node) ? Y_DOM._getDoc(node) : Y.config.doc;
          var 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 = (node) ? Y_DOM._getDoc(node) : Y.config.doc,
              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)
       * @for DOM
       * @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 passed nodes.
       * @method intersect
       * @for DOM
       * @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 e.g. 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
       * @for DOM
       * @param {Object} node The node to get the region from
       * @param {Object} node2 The second 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 e.g. 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
       * @for DOM
       * @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 e.g. 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
       * @for DOM
       * @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);
  
  
  }, '@VERSION@' ,{requires:['dom-base', 'dom-style']});
  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 COMPARE_DOCUMENT_POSITION = 'compareDocumentPosition',
      OWNER_DOCUMENT = 'ownerDocument';
  
  var Selector = {
      _types: {
          esc: {
              token: '\uE000',
              re: /\\[:\[\]\(\)#\.\'\>+~"]/gi
          },
  
          attr: {
              token: '\uE001',
              re: /(\[[^\]]*\])/g
          },
  
          pseudo: {
              token: '\uE002',
              re: /(\([^\)]*\))/g
          }
      },
  
      useNative: true,
  
      _escapeId: function(id) {
          if (id) {
              id = id.replace(/([:\[\]\(\)#\.'<>+~"])/g,'\\$1');
          }
          return id;
      },
  
      _compare: ('sourceIndex' in Y.config.doc.documentElement) ?
          function(nodeA, nodeB) {
              var a = nodeA.sourceIndex,
                  b = nodeB.sourceIndex;
  
              if (a === b) {
                  return 0;
              } else if (a > b) {
                  return 1;
              }
  
              return -1;
  
          } : (Y.config.doc.documentElement[COMPARE_DOCUMENT_POSITION] ?
          function(nodeA, nodeB) {
              if (nodeA[COMPARE_DOCUMENT_POSITION](nodeB) & 4) {
                  return -1;
              } else {
                  return 1;
              }
          } :
          function(nodeA, nodeB) {
              var rangeA, rangeB, compare;
              if (nodeA && nodeB) {
                  rangeA = nodeA[OWNER_DOCUMENT].createRange();
                  rangeA.setStart(nodeA, 0);
                  rangeB = nodeB[OWNER_DOCUMENT].createRange();
                  rangeB.setStart(nodeB, 0);
                  compare = rangeA.compareBoundaryPoints(1, rangeB); // 1 === Range.START_TO_END
              }
  
              return compare;
          
      }),
  
      _sort: function(nodes) {
          if (nodes) {
              nodes = Y.Array(nodes, 0, true);
              if (nodes.sort) {
                  nodes.sort(Selector._compare);
              }
          }
  
          return nodes;
      },
  
      _deDupe: function(nodes) {
          var ret = [],
              i, node;
  
          for (i = 0; (node = nodes[i++]);) {
              if (!node._found) {
                  ret[ret.length] = node;
                  node._found = true;
              }
          }
  
          for (i = 0; (node = ret[i++]);) {
              node._found = null;
              node.removeAttribute('_found');
          }
  
          return ret;
      },
  
      /**
       * 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, skipNative) {
          root = root || Y.config.doc;
          var ret = [],
              useNative = (Y.Selector.useNative && Y.config.doc.querySelector && !skipNative),
              queries = [[selector, root]],
              query,
              result,
              i,
              fn = (useNative) ? Y.Selector._nativeQuery : Y.Selector._bruteQuery;
  
          if (selector && fn) {
              // split group into seperate queries
              if (!skipNative && // already done if skipping
                      (!useNative || root.tagName)) { // split native when element scoping is needed
                  queries = Selector._splitQueries(selector, root);
              }
  
              for (i = 0; (query = queries[i++]);) {
                  result = fn(query[0], query[1], firstOnly);
                  if (!firstOnly) { // coerce DOM Collection to Array
                      result = Y.Array(result, 0, true);
                  }
                  if (result) {
                      ret = ret.concat(result);
                  }
              }
  
              if (queries.length > 1) { // remove dupes and sort by doc order 
                  ret = Selector._sort(Selector._deDupe(ret));
              }
          }
  
          return (firstOnly) ? (ret[0] || null) : ret;
  
      },
  
      _replaceSelector: function(selector) {
          var esc = Y.Selector._parse('esc', selector), // pull escaped colon, brackets, etc. 
              attrs,
              pseudos;
  
          // first replace escaped chars, which could be present in attrs or pseudos
          selector = Y.Selector._replace('esc', selector);
  
          // then replace pseudos before attrs to avoid replacing :not([foo])
          pseudos = Y.Selector._parse('pseudo', selector);
          selector = Selector._replace('pseudo', selector);
  
          attrs = Y.Selector._parse('attr', selector);
          selector = Y.Selector._replace('attr', selector);
  
          return {
              esc: esc,
              attrs: attrs,
              pseudos: pseudos,
              selector: selector
          }
      },
  
      _restoreSelector: function(replaced) {
          var selector = replaced.selector;
          selector = Y.Selector._restore('attr', selector, replaced.attrs);
          selector = Y.Selector._restore('pseudo', selector, replaced.pseudos);
          selector = Y.Selector._restore('esc', selector, replaced.esc);
          return selector;
      },
  
      _replaceCommas: function(selector) {
          var replaced = Y.Selector._replaceSelector(selector),
              selector = replaced.selector;
  
          if (selector) {
              selector = selector.replace(/,/g, '\uE007');
              replaced.selector = selector;
              selector = Y.Selector._restoreSelector(replaced);
          }
          return selector;
      },
  
      // allows element scoped queries to begin with combinator
      // e.g. query('> p', document.body) === query('body > p')
      _splitQueries: function(selector, node) {
          if (selector.indexOf(',') > -1) {
              selector = Y.Selector._replaceCommas(selector);
          }
  
          var groups = selector.split('\uE007'), // split on replaced comma token
              queries = [],
              prefix = '',
              id,
              i,
              len;
  
          if (node) {
              // enforce for element scoping
              if (node.nodeType === 1) { // Elements only
                  id = Y.Selector._escapeId(Y.DOM.getId(node));
  
                  if (!id) {
                      id = Y.guid();
                      Y.DOM.setId(node, id);
                  }
              
                  prefix = '[id="' + id + '"] ';
              }
  
              for (i = 0, len = groups.length; i < len; ++i) {
                  selector =  prefix + groups[i];
                  queries.push([selector, node]);
              }
          }
  
          return queries;
      },
  
      _nativeQuery: function(selector, root, one) {
          if (Y.UA.webkit && selector.indexOf(':checked') > -1 &&
                  (Y.Selector.pseudos && Y.Selector.pseudos.checked)) { // webkit (chrome, safari) fails to pick up "selected"  with "checked"
              return Y.Selector.query(selector, root, one, true); // redo with skipNative true to try brute query
          }
          try {
              return root['querySelector' + (one ? '' : 'All')](selector);
          } catch(e) { // fallback to brute if available
              return Y.Selector.query(selector, root, one, true); // redo with skipNative true
          }
      },
  
      filter: function(nodes, selector) {
          var ret = [],
              i, node;
  
          if (nodes && selector) {
              for (i = 0; (node = nodes[i++]);) {
                  if (Y.Selector.test(node, selector)) {
                      ret[ret.length] = node;
                  }
              }
          } else {
          }
  
          return ret;
      },
  
      test: function(node, selector, root) {
          var ret = false,
              useFrag = false,
              groups,
              parent,
              item,
              items,
              frag,
              id,
              i, j, group;
  
          if (node && node.tagName) { // only test HTMLElements
  
              if (typeof selector == 'function') { // test with function
                  ret = selector.call(node, node);
              } else { // test with query
                  // we need a root if off-doc
                  groups = selector.split(',');
                  if (!root && !Y.DOM.inDoc(node)) {
                      parent = node.parentNode;
                      if (parent) { 
                          root = parent;
                      } else { // only use frag when no parent to query
                          frag = node[OWNER_DOCUMENT].createDocumentFragment();
                          frag.appendChild(node);
                          root = frag;
                          useFrag = true;
                      }
                  }
                  root = root || node[OWNER_DOCUMENT];
  
                  id = Y.Selector._escapeId(Y.DOM.getId(node));
                  if (!id) {
                      id = Y.guid();
                      Y.DOM.setId(node, id);
                  }
  
                  for (i = 0; (group = groups[i++]);) { // TODO: off-dom test
                      group += '[id="' + id + '"]';
                      items = Y.Selector.query(group, root);
  
                      for (j = 0; item = items[j++];) {
                          if (item === node) {
                              ret = true;
                              break;
                          }
                      }
                      if (ret) {
                          break;
                      }
                  }
  
                  if (useFrag) { // cleanup
                      frag.removeChild(node);
                  }
              };
          }
  
          return ret;
      },
  
      /**
       * A convenience function to emulate Y.Node's aNode.ancestor(selector).
       * @param {HTMLElement} element An HTMLElement to start the query from.
       * @param {String} selector The CSS selector to test the node against.
       * @return {HTMLElement} The ancestor node matching the selector, or null.
       * @param {Boolean} testSelf optional Whether or not to include the element in the scan 
       * @static
       * @method ancestor
       */
      ancestor: function (element, selector, testSelf) {
          return Y.DOM.ancestor(element, function(n) {
              return Y.Selector.test(n, selector);
          }, testSelf);
      },
  
      _parse: function(name, selector) {
          return selector.match(Y.Selector._types[name].re);
      },
  
      _replace: function(name, selector) {
          var o = Y.Selector._types[name];
          return selector.replace(o.re, o.token);
      },
  
      _restore: function(name, selector, items) {
          if (items) {
              var token = Y.Selector._types[name].token,
                  i, len;
              for (i = 0, len = items.length; i < len; ++i) {
                  selector = selector.replace(token, items[i]);
              }
          }
          return selector;
      }
  };
  
  Y.mix(Y.Selector, Selector, true);
  
  })(Y);
  
  
  }, '@VERSION@' ,{requires:['dom-base']});
  YUI.add('selector', function(Y) {
  
  
  
  
  }, '@VERSION@' ,{requires:['selector-native']});
  YUI.add('event-custom-base', function(Y) {
  
  /**
   * Custom event engine, DOM event listener abstraction layer, synthetic DOM
   * events.
   * @module event-custom
   */
  
  Y.Env.evt = {
      handles: {},
      plugins: {}
  };
  
  
  /**
   * Custom event engine, DOM event listener abstraction layer, synthetic DOM
   * events.
   * @module event-custom
   * @submodule event-custom-base
   */
  
  /**
   * Allows for the insertion of methods that are executed before or after
   * a specified method
   * @class Do
   * @static
   */
  
  var DO_BEFORE = 0,
      DO_AFTER = 1,
  
  DO = {
  
      /**
       * Cache of objects touched by the utility
       * @property objs
       * @static
       * @deprecated Since 3.6.0. The `_yuiaop` property on the AOP'd object 
       * replaces the role of this property, but is considered to be private, and 
       * is only mentioned to provide a migration path.
       * 
       * If you have a use case which warrants migration to the _yuiaop property, 
       * please file a ticket to let us know what it's used for and we can see if 
       * we need to expose hooks for that functionality more formally.
       */
      objs: null,
  
      /**
       * <p>Execute the supplied method before the specified function.  Wrapping
       * function may optionally return an instance of the following classes to
       * further alter runtime behavior:</p>
       * <dl>
       *     <dt></code>Y.Do.Halt(message, returnValue)</code></dt>
       *         <dd>Immediatly stop execution and return
       *         <code>returnValue</code>.  No other wrapping functions will be
       *         executed.</dd>
       *     <dt></code>Y.Do.AlterArgs(message, newArgArray)</code></dt>
       *         <dd>Replace the arguments that the original function will be
       *         called with.</dd>
       *     <dt></code>Y.Do.Prevent(message)</code></dt>
       *         <dd>Don't execute the wrapped function.  Other before phase
       *         wrappers will be executed.</dd>
       * </dl>
       *
       * @method before
       * @param fn {Function} the function to execute
       * @param obj the object hosting the method to displace
       * @param sFn {string} the name of the method to displace
       * @param c The execution context for fn
       * @param arg* {mixed} 0..n additional arguments to supply to the subscriber
       * when the event fires.
       * @return {string} handle for the subscription
       * @static
       */
      before: function(fn, obj, sFn, c) {
          var f = fn, a;
          if (c) {
              a = [fn, c].concat(Y.Array(arguments, 4, true));
              f = Y.rbind.apply(Y, a);
          }
  
          return this._inject(DO_BEFORE, f, obj, sFn);
      },
  
      /**
       * <p>Execute the supplied method after the specified function.  Wrapping
       * function may optionally return an instance of the following classes to
       * further alter runtime behavior:</p>
       * <dl>
       *     <dt></code>Y.Do.Halt(message, returnValue)</code></dt>
       *         <dd>Immediatly stop execution and return
       *         <code>returnValue</code>.  No other wrapping functions will be
       *         executed.</dd>
       *     <dt></code>Y.Do.AlterReturn(message, returnValue)</code></dt>
       *         <dd>Return <code>returnValue</code> instead of the wrapped
       *         method's original return value.  This can be further altered by
       *         other after phase wrappers.</dd>
       * </dl>
       *
       * <p>The static properties <code>Y.Do.originalRetVal</code> and
       * <code>Y.Do.currentRetVal</code> will be populated for reference.</p>
       *
       * @method after
       * @param fn {Function} the function to execute
       * @param obj the object hosting the method to displace
       * @param sFn {string} the name of the method to displace
       * @param c The execution context for fn
       * @param arg* {mixed} 0..n additional arguments to supply to the subscriber
       * @return {string} handle for the subscription
       * @static
       */
      after: function(fn, obj, sFn, c) {
          var f = fn, a;
          if (c) {
              a = [fn, c].concat(Y.Array(arguments, 4, true));
              f = Y.rbind.apply(Y, a);
          }
  
          return this._inject(DO_AFTER, f, obj, sFn);
      },
  
      /**
       * Execute the supplied method before or after the specified function.
       * Used by <code>before</code> and <code>after</code>.
       *
       * @method _inject
       * @param when {string} before or after
       * @param fn {Function} the function to execute
       * @param obj the object hosting the method to displace
       * @param sFn {string} the name of the method to displace
       * @param c The execution context for fn
       * @return {string} handle for the subscription
       * @private
       * @static
       */
      _inject: function(when, fn, obj, sFn) {
          // object id
          var id = Y.stamp(obj), o, sid;
  
          if (!obj._yuiaop) {
              // create a map entry for the obj if it doesn't exist, to hold overridden methods
              obj._yuiaop = {};
          }
  
          o = obj._yuiaop;
  
          if (!o[sFn]) {
              // create a map entry for the method if it doesn't exist
              o[sFn] = new Y.Do.Method(obj, sFn);
  
              // re-route the method to our wrapper
              obj[sFn] = function() {
                  return o[sFn].exec.apply(o[sFn], arguments);
              };
          }
  
          // subscriber id
          sid = id + Y.stamp(fn) + sFn;
  
          // register the callback
          o[sFn].register(sid, fn, when);
  
          return new Y.EventHandle(o[sFn], sid);
      },
  
      /**
       * Detach a before or after subscription.
       *
       * @method detach
       * @param handle {string} the subscription handle
       * @static
       */
      detach: function(handle) {
          if (handle.detach) {
              handle.detach();
          }
      },
  
      _unload: function(e, me) {
      }
  };
  
  Y.Do = DO;
  
  //////////////////////////////////////////////////////////////////////////
  
  /**
   * Contains the return value from the wrapped method, accessible
   * by 'after' event listeners.
   *
   * @property originalRetVal
   * @static
   * @since 3.2.0
   */
  
  /**
   * Contains the current state of the return value, consumable by
   * 'after' event listeners, and updated if an after subscriber
   * changes the return value generated by the wrapped function.
   *
   * @property currentRetVal
   * @static
   * @since 3.2.0
   */
  
  //////////////////////////////////////////////////////////////////////////
  
  /**
   * Wrapper for a displaced method with aop enabled
   * @class Do.Method
   * @constructor
   * @param obj The object to operate on
   * @param sFn The name of the method to displace
   */
  DO.Method = function(obj, sFn) {
      this.obj = obj;
      this.methodName = sFn;
      this.method = obj[sFn];
      this.before = {};
      this.after = {};
  };
  
  /**
   * Register a aop subscriber
   * @method register
   * @param sid {string} the subscriber id
   * @param fn {Function} the function to execute
   * @param when {string} when to execute the function
   */
  DO.Method.prototype.register = function (sid, fn, when) {
      if (when) {
          this.after[sid] = fn;
      } else {
          this.before[sid] = fn;
      }
  };
  
  /**
   * Unregister a aop subscriber
   * @method delete
   * @param sid {string} the subscriber id
   * @param fn {Function} the function to execute
   * @param when {string} when to execute the function
   */
  DO.Method.prototype._delete = function (sid) {
      delete this.before[sid];
      delete this.after[sid];
  };
  
  /**
   * <p>Execute the wrapped method.  All arguments are passed into the wrapping
   * functions.  If any of the before wrappers return an instance of
   * <code>Y.Do.Halt</code> or <code>Y.Do.Prevent</code>, neither the wrapped
   * function nor any after phase subscribers will be executed.</p>
   *
   * <p>The return value will be the return value of the wrapped function or one
   * provided by a wrapper function via an instance of <code>Y.Do.Halt</code> or
   * <code>Y.Do.AlterReturn</code>.
   *
   * @method exec
   * @param arg* {any} Arguments are passed to the wrapping and wrapped functions
   * @return {any} Return value of wrapped function unless overwritten (see above)
   */
  DO.Method.prototype.exec = function () {
  
      var args = Y.Array(arguments, 0, true),
          i, ret, newRet,
          bf = this.before,
          af = this.after,
          prevented = false;
  
      // execute before
      for (i in bf) {
          if (bf.hasOwnProperty(i)) {
              ret = bf[i].apply(this.obj, args);
              if (ret) {
                  switch (ret.constructor) {
                      case DO.Halt:
                          return ret.retVal;
                      case DO.AlterArgs:
                          args = ret.newArgs;
                          break;
                      case DO.Prevent:
                          prevented = true;
                          break;
                      default:
                  }
              }
          }
      }
  
      // execute method
      if (!prevented) {
          ret = this.method.apply(this.obj, args);
      }
  
      DO.originalRetVal = ret;
      DO.currentRetVal = ret;
  
      // execute after methods.
      for (i in af) {
          if (af.hasOwnProperty(i)) {
              newRet = af[i].apply(this.obj, args);
              // Stop processing if a Halt object is returned
              if (newRet && newRet.constructor == DO.Halt) {
                  return newRet.retVal;
              // Check for a new return value
              } else if (newRet && newRet.constructor == DO.AlterReturn) {
                  ret = newRet.newRetVal;
                  // Update the static retval state
                  DO.currentRetVal = ret;
              }
          }
      }
  
      return ret;
  };
  
  //////////////////////////////////////////////////////////////////////////
  
  /**
   * Return an AlterArgs object when you want to change the arguments that
   * were passed into the function.  Useful for Do.before subscribers.  An
   * example would be a service that scrubs out illegal characters prior to
   * executing the core business logic.
   * @class Do.AlterArgs
   * @constructor
   * @param msg {String} (optional) Explanation of the altered return value
   * @param newArgs {Array} Call parameters to be used for the original method
   *                        instead of the arguments originally passed in.
   */
  DO.AlterArgs = function(msg, newArgs) {
      this.msg = msg;
      this.newArgs = newArgs;
  };
  
  /**
   * Return an AlterReturn object when you want to change the result returned
   * from the core method to the caller.  Useful for Do.after subscribers.
   * @class Do.AlterReturn
   * @constructor
   * @param msg {String} (optional) Explanation of the altered return value
   * @param newRetVal {any} Return value passed to code that invoked the wrapped
   *                      function.
   */
  DO.AlterReturn = function(msg, newRetVal) {
      this.msg = msg;
      this.newRetVal = newRetVal;
  };
  
  /**
   * Return a Halt object when you want to terminate the execution
   * of all subsequent subscribers as well as the wrapped method
   * if it has not exectued yet.  Useful for Do.before subscribers.
   * @class Do.Halt
   * @constructor
   * @param msg {String} (optional) Explanation of why the termination was done
   * @param retVal {any} Return value passed to code that invoked the wrapped
   *                      function.
   */
  DO.Halt = function(msg, retVal) {
      this.msg = msg;
      this.retVal = retVal;
  };
  
  /**
   * Return a Prevent object when you want to prevent the wrapped function
   * from executing, but want the remaining listeners to execute.  Useful
   * for Do.before subscribers.
   * @class Do.Prevent
   * @constructor
   * @param msg {String} (optional) Explanation of why the termination was done
   */
  DO.Prevent = function(msg) {
      this.msg = msg;
  };
  
  /**
   * Return an Error object when you want to terminate the execution
   * of all subsequent method calls.
   * @class Do.Error
   * @constructor
   * @param msg {String} (optional) Explanation of the altered return value
   * @param retVal {any} Return value passed to code that invoked the wrapped
   *                      function.
   * @deprecated use Y.Do.Halt or Y.Do.Prevent
   */
  DO.Error = DO.Halt;
  
  
  //////////////////////////////////////////////////////////////////////////
  
  // Y["Event"] && Y.Event.addListener(window, "unload", Y.Do._unload, Y.Do);
  
  
  /**
   * Custom event engine, DOM event listener abstraction layer, synthetic DOM
   * events.
   * @module event-custom
   * @submodule event-custom-base
   */
  
  
  // var onsubscribeType = "_event:onsub",
  var AFTER = 'after',
      CONFIGS = [
          'broadcast',
          'monitored',
          'bubbles',
          'context',
          'contextFn',
          'currentTarget',
          'defaultFn',
          'defaultTargetOnly',
          'details',
          'emitFacade',
          'fireOnce',
          'async',
          'host',
          'preventable',
          'preventedFn',
          'queuable',
          'silent',
          'stoppedFn',
          'target',
          'type'
      ],
  
      YUI3_SIGNATURE = 9,
      YUI_LOG = 'yui:log';
  
  /**
   * The CustomEvent class lets you define events for your application
   * that can be subscribed to by one or more independent component.
   *
   * @param {String} type The type of event, which is passed to the callback
   * when the event fires.
   * @param {object} o configuration object.
   * @class CustomEvent
   * @constructor
   */
  Y.CustomEvent = function(type, o) {
  
      // if (arguments.length > 2) {
  // this.log('CustomEvent context and silent are now in the config', 'warn', 'Event');
      // }
  
      o = o || {};
  
      this.id = Y.stamp(this);
  
      /**
       * The type of event, returned to subscribers when the event fires
       * @property type
       * @type string
       */
      this.type = type;
  
      /**
       * The context the the event will fire from by default.  Defaults to the YUI
       * instance.
       * @property context
       * @type object
       */
      this.context = Y;
  
      /**
       * Monitor when an event is attached or detached.
       *
       * @property monitored
       * @type boolean
       */
      // this.monitored = false;
  
      this.logSystem = (type == YUI_LOG);
  
      /**
       * If 0, this event does not broadcast.  If 1, the YUI instance is notified
       * every time this event fires.  If 2, the YUI instance and the YUI global
       * (if event is enabled on the global) are notified every time this event
       * fires.
       * @property broadcast
       * @type int
       */
      // this.broadcast = 0;
  
      /**
       * By default all custom events are logged in the debug build, set silent
       * to true to disable debug outpu for this event.
       * @property silent
       * @type boolean
       */
      this.silent = this.logSystem;
  
      /**
       * Specifies whether this event should be queued when the host is actively
       * processing an event.  This will effect exectution order of the callbacks
       * for the various events.
       * @property queuable
       * @type boolean
       * @default false
       */
      // this.queuable = false;
  
      /**
       * The subscribers to this event
       * @property subscribers
       * @type Subscriber {}
       */
      this.subscribers = {};
  
      /**
       * 'After' subscribers
       * @property afters
       * @type Subscriber {}
       */
      this.afters = {};
  
      /**
       * This event has fired if true
       *
       * @property fired
       * @type boolean
       * @default false;
       */
      // this.fired = false;
  
      /**
       * An array containing the arguments the custom event
       * was last fired with.
       * @property firedWith
       * @type Array
       */
      // this.firedWith;
  
      /**
       * This event should only fire one time if true, and if
       * it has fired, any new subscribers should be notified
       * immediately.
       *
       * @property fireOnce
       * @type boolean
       * @default false;
       */
      // this.fireOnce = false;
  
      /**
       * fireOnce listeners will fire syncronously unless async
       * is set to true
       * @property async
       * @type boolean
       * @default false
       */
      //this.async = false;
  
      /**
       * Flag for stopPropagation that is modified during fire()
       * 1 means to stop propagation to bubble targets.  2 means
       * to also stop additional subscribers on this target.
       * @property stopped
       * @type int
       */
      // this.stopped = 0;
  
      /**
       * Flag for preventDefault that is modified during fire().
       * if it is not 0, the default behavior for this event
       * @property prevented
       * @type int
       */
      // this.prevented = 0;
  
      /**
       * Specifies the host for this custom event.  This is used
       * to enable event bubbling
       * @property host
       * @type EventTarget
       */
      // this.host = null;
  
      /**
       * The default function to execute after event listeners
       * have fire, but only if the default action was not
       * prevented.
       * @property defaultFn
       * @type Function
       */
      // this.defaultFn = null;
  
      /**
       * The function to execute if a subscriber calls
       * stopPropagation or stopImmediatePropagation
       * @property stoppedFn
       * @type Function
       */
      // this.stoppedFn = null;
  
      /**
       * The function to execute if a subscriber calls
       * preventDefault
       * @property preventedFn
       * @type Function
       */
      // this.preventedFn = null;
  
      /**
       * Specifies whether or not this event's default function
       * can be cancelled by a subscriber by executing preventDefault()
       * on the event facade
       * @property preventable
       * @type boolean
       * @default true
       */
      this.preventable = true;
  
      /**
       * Specifies whether or not a subscriber can stop the event propagation
       * via stopPropagation(), stopImmediatePropagation(), or halt()
       *
       * Events can only bubble if emitFacade is true.
       *
       * @property bubbles
       * @type boolean
       * @default true
       */
      this.bubbles = true;
  
      /**
       * Supports multiple options for listener signatures in order to
       * port YUI 2 apps.
       * @property signature
       * @type int
       * @default 9
       */
      this.signature = YUI3_SIGNATURE;
  
      this.subCount = 0;
      this.afterCount = 0;
  
      // this.hasSubscribers = false;
  
      // this.hasAfters = false;
  
      /**
       * If set to true, the custom event will deliver an EventFacade object
       * that is similar to a DOM event object.
       * @property emitFacade
       * @type boolean
       * @default false
       */
      // this.emitFacade = false;
  
      this.applyConfig(o, true);
  
      // this.log("Creating " + this.type);
  
  };
  
  Y.CustomEvent.prototype = {
      constructor: Y.CustomEvent,
  
      /**
       * Returns the number of subscribers for this event as the sum of the on()
       * subscribers and after() subscribers.
       *
       * @method hasSubs
       * @return Number
       */
      hasSubs: function(when) {
          var s = this.subCount, a = this.afterCount, sib = this.sibling;
  
          if (sib) {
              s += sib.subCount;
              a += sib.afterCount;
          }
  
          if (when) {
              return (when == 'after') ? a : s;
          }
  
          return (s + a);
      },
  
      /**
       * Monitor the event state for the subscribed event.  The first parameter
       * is what should be monitored, the rest are the normal parameters when
       * subscribing to an event.
       * @method monitor
       * @param what {string} what to monitor ('detach', 'attach', 'publish').
       * @return {EventHandle} return value from the monitor event subscription.
       */
      monitor: function(what) {
          this.monitored = true;
          var type = this.id + '|' + this.type + '_' + what,
              args = Y.Array(arguments, 0, true);
          args[0] = type;
          return this.host.on.apply(this.host, args);
      },
  
      /**
       * Get all of the subscribers to this event and any sibling event
       * @method getSubs
       * @return {Array} first item is the on subscribers, second the after.
       */
      getSubs: function() {
          var s = Y.merge(this.subscribers), a = Y.merge(this.afters), sib = this.sibling;
  
          if (sib) {
              Y.mix(s, sib.subscribers);
              Y.mix(a, sib.afters);
          }
  
          return [s, a];
      },
  
      /**
       * Apply configuration properties.  Only applies the CONFIG whitelist
       * @method applyConfig
       * @param o hash of properties to apply.
       * @param force {boolean} if true, properties that exist on the event
       * will be overwritten.
       */
      applyConfig: function(o, force) {
          if (o) {
              Y.mix(this, o, force, CONFIGS);
          }
      },
  
      /**
       * Create the Subscription for subscribing function, context, and bound
       * arguments.  If this is a fireOnce event, the subscriber is immediately 
       * notified.
       *
       * @method _on
       * @param fn {Function} Subscription callback
       * @param [context] {Object} Override `this` in the callback
       * @param [args] {Array} bound arguments that will be passed to the callback after the arguments generated by fire()
       * @param [when] {String} "after" to slot into after subscribers
       * @return {EventHandle}
       * @protected
       */
      _on: function(fn, context, args, when) {
  
          if (!fn) {
              this.log('Invalid callback for CE: ' + this.type);
          }
  
          var s = new Y.Subscriber(fn, context, args, when);
  
          if (this.fireOnce && this.fired) {
              if (this.async) {
                  setTimeout(Y.bind(this._notify, this, s, this.firedWith), 0);
              } else {
                  this._notify(s, this.firedWith);
              }
          }
  
          if (when == AFTER) {
              this.afters[s.id] = s;
              this.afterCount++;
          } else {
              this.subscribers[s.id] = s;
              this.subCount++;
          }
  
          return new Y.EventHandle(this, s);
  
      },
  
      /**
       * Listen for this event
       * @method subscribe
       * @param {Function} fn The function to execute.
       * @return {EventHandle} Unsubscribe handle.
       * @deprecated use on.
       */
      subscribe: function(fn, context) {
          var a = (arguments.length > 2) ? Y.Array(arguments, 2, true) : null;
          return this._on(fn, context, a, true);
      },
  
      /**
       * Listen for this event
       * @method on
       * @param {Function} fn The function to execute.
       * @param {object} context optional execution context.
       * @param {mixed} arg* 0..n additional arguments to supply to the subscriber
       * when the event fires.
       * @return {EventHandle} An object with a detach method to detch the handler(s).
       */
      on: function(fn, context) {
          var a = (arguments.length > 2) ? Y.Array(arguments, 2, true) : null;
          if (this.host) {
              this.host._monitor('attach', this.type, {
                  args: arguments
              });
          }
          return this._on(fn, context, a, true);
      },
  
      /**
       * Listen for this event after the normal subscribers have been notified and
       * the default behavior has been applied.  If a normal subscriber prevents the
       * default behavior, it also prevents after listeners from firing.
       * @method after
       * @param {Function} fn The function to execute.
       * @param {object} context optional execution context.
       * @param {mixed} arg* 0..n additional arguments to supply to the subscriber
       * when the event fires.
       * @return {EventHandle} handle Unsubscribe handle.
       */
      after: function(fn, context) {
          var a = (arguments.length > 2) ? Y.Array(arguments, 2, true) : null;
          return this._on(fn, context, a, AFTER);
      },
  
      /**
       * Detach listeners.
       * @method detach
       * @param {Function} fn  The subscribed function to remove, if not supplied
       *                       all will be removed.
       * @param {Object}   context The context object passed to subscribe.
       * @return {int} returns the number of subscribers unsubscribed.
       */
      detach: function(fn, context) {
          // unsubscribe handle
          if (fn && fn.detach) {
              return fn.detach();
          }
  
          var i, s,
              found = 0,
              subs = Y.merge(this.subscribers, this.afters);
  
          for (i in subs) {
              if (subs.hasOwnProperty(i)) {
                  s = subs[i];
                  if (s && (!fn || fn === s.fn)) {
                      this._delete(s);
                      found++;
                  }
              }
          }
  
          return found;
      },
  
      /**
       * Detach listeners.
       * @method unsubscribe
       * @param {Function} fn  The subscribed function to remove, if not supplied
       *                       all will be removed.
       * @param {Object}   context The context object passed to subscribe.
       * @return {int|undefined} returns the number of subscribers unsubscribed.
       * @deprecated use detach.
       */
      unsubscribe: function() {
          return this.detach.apply(this, arguments);
      },
  
      /**
       * Notify a single subscriber
       * @method _notify
       * @param {Subscriber} s the subscriber.
       * @param {Array} args the arguments array to apply to the listener.
       * @protected
       */
      _notify: function(s, args, ef) {
  
          this.log(this.type + '->' + 'sub: ' + s.id);
  
          var ret;
  
          ret = s.notify(args, this);
  
          if (false === ret || this.stopped > 1) {
              this.log(this.type + ' cancelled by subscriber');
              return false;
          }
  
          return true;
      },
  
      /**
       * Logger abstraction to centralize the application of the silent flag
       * @method log
       * @param {string} msg message to log.
       * @param {string} cat log category.
       */
      log: function(msg, cat) {
          if (!this.silent) {
          }
      },
  
      /**
       * Notifies the subscribers.  The callback functions will be executed
       * from the context specified when the event was created, and with the
       * following parameters:
       *   <ul>
       *   <li>The type of event</li>
       *   <li>All of the arguments fire() was executed with as an array</li>
       *   <li>The custom object (if any) that was passed into the subscribe()
       *       method</li>
       *   </ul>
       * @method fire
       * @param {Object*} arguments an arbitrary set of parameters to pass to
       *                            the handler.
       * @return {boolean} false if one of the subscribers returned false,
       *                   true otherwise.
       *
       */
      fire: function() {
          if (this.fireOnce && this.fired) {
              this.log('fireOnce event: ' + this.type + ' already fired');
              return true;
          } else {
  
              var args = Y.Array(arguments, 0, true);
  
              // this doesn't happen if the event isn't published
              // this.host._monitor('fire', this.type, args);
  
              this.fired = true;
              this.firedWith = args;
  
              if (this.emitFacade) {
                  return this.fireComplex(args);
              } else {
                  return this.fireSimple(args);
              }
          }
      },
  
      /**
       * Set up for notifying subscribers of non-emitFacade events.
       *
       * @method fireSimple
       * @param args {Array} Arguments passed to fire()
       * @return Boolean false if a subscriber returned false
       * @protected
       */
      fireSimple: function(args) {
          this.stopped = 0;
          this.prevented = 0;
          if (this.hasSubs()) {
              // this._procSubs(Y.merge(this.subscribers, this.afters), args);
              var subs = this.getSubs();
              this._procSubs(subs[0], args);
              this._procSubs(subs[1], args);
          }
          this._broadcast(args);
          return this.stopped ? false : true;
      },
  
      // Requires the event-custom-complex module for full funcitonality.
      fireComplex: function(args) {
          args[0] = args[0] || {};
          return this.fireSimple(args);
      },
  
      /**
       * Notifies a list of subscribers.
       *
       * @method _procSubs
       * @param subs {Array} List of subscribers
       * @param args {Array} Arguments passed to fire()
       * @param ef {}
       * @return Boolean false if a subscriber returns false or stops the event
       *              propagation via e.stopPropagation(),
       *              e.stopImmediatePropagation(), or e.halt()
       * @private
       */
      _procSubs: function(subs, args, ef) {
          var s, i;
          for (i in subs) {
              if (subs.hasOwnProperty(i)) {
                  s = subs[i];
                  if (s && s.fn) {
                      if (false === this._notify(s, args, ef)) {
                          this.stopped = 2;
                      }
                      if (this.stopped == 2) {
                          return false;
                      }
                  }
              }
          }
  
          return true;
      },
  
      /**
       * Notifies the YUI instance if the event is configured with broadcast = 1,
       * and both the YUI instance and Y.Global if configured with broadcast = 2.
       *
       * @method _broadcast
       * @param args {Array} Arguments sent to fire()
       * @private
       */
      _broadcast: function(args) {
          if (!this.stopped && this.broadcast) {
  
              var a = Y.Array(args);
              a.unshift(this.type);
  
              if (this.host !== Y) {
                  Y.fire.apply(Y, a);
              }
  
              if (this.broadcast == 2) {
                  Y.Global.fire.apply(Y.Global, a);
              }
          }
      },
  
      /**
       * Removes all listeners
       * @method unsubscribeAll
       * @return {int} The number of listeners unsubscribed.
       * @deprecated use detachAll.
       */
      unsubscribeAll: function() {
          return this.detachAll.apply(this, arguments);
      },
  
      /**
       * Removes all listeners
       * @method detachAll
       * @return {int} The number of listeners unsubscribed.
       */
      detachAll: function() {
          return this.detach();
      },
  
      /**
       * Deletes the subscriber from the internal store of on() and after()
       * subscribers.
       *
       * @method _delete
       * @param subscriber object.
       * @private
       */
      _delete: function(s) {
          if (s) {
              if (this.subscribers[s.id]) {
                  delete this.subscribers[s.id];
                  this.subCount--;
              }
              if (this.afters[s.id]) {
                  delete this.afters[s.id];
                  this.afterCount--;
              }
          }
  
          if (this.host) {
              this.host._monitor('detach', this.type, {
                  ce: this,
                  sub: s
              });
          }
  
          if (s) {
              // delete s.fn;
              // delete s.context;
              s.deleted = true;
          }
      }
  };
  /**
   * Stores the subscriber information to be used when the event fires.
   * @param {Function} fn       The wrapped function to execute.
   * @param {Object}   context  The value of the keyword 'this' in the listener.
   * @param {Array} args*       0..n additional arguments to supply the listener.
   *
   * @class Subscriber
   * @constructor
   */
  Y.Subscriber = function(fn, context, args) {
  
      /**
       * The callback that will be execute when the event fires
       * This is wrapped by Y.rbind if obj was supplied.
       * @property fn
       * @type Function
       */
      this.fn = fn;
  
      /**
       * Optional 'this' keyword for the listener
       * @property context
       * @type Object
       */
      this.context = context;
  
      /**
       * Unique subscriber id
       * @property id
       * @type String
       */
      this.id = Y.stamp(this);
  
      /**
       * Additional arguments to propagate to the subscriber
       * @property args
       * @type Array
       */
      this.args = args;
  
      /**
       * Custom events for a given fire transaction.
       * @property events
       * @type {EventTarget}
       */
      // this.events = null;
  
      /**
       * This listener only reacts to the event once
       * @property once
       */
      // this.once = false;
  
  };
  
  Y.Subscriber.prototype = {
      constructor: Y.Subscriber,
  
      _notify: function(c, args, ce) {
          if (this.deleted && !this.postponed) {
              if (this.postponed) {
                  delete this.fn;
                  delete this.context;
              } else {
                  delete this.postponed;
                  return null;
              }
          }
          var a = this.args, ret;
          switch (ce.signature) {
              case 0:
                  ret = this.fn.call(c, ce.type, args, c);
                  break;
              case 1:
                  ret = this.fn.call(c, args[0] || null, c);
                  break;
              default:
                  if (a || args) {
                      args = args || [];
                      a = (a) ? args.concat(a) : args;
                      ret = this.fn.apply(c, a);
                  } else {
                      ret = this.fn.call(c);
                  }
          }
  
          if (this.once) {
              ce._delete(this);
          }
  
          return ret;
      },
  
      /**
       * Executes the subscriber.
       * @method notify
       * @param args {Array} Arguments array for the subscriber.
       * @param ce {CustomEvent} The custom event that sent the notification.
       */
      notify: function(args, ce) {
          var c = this.context,
              ret = true;
  
          if (!c) {
              c = (ce.contextFn) ? ce.contextFn() : ce.context;
          }
  
          // only catch errors if we will not re-throw them.
          if (Y.config && Y.config.throwFail) {
              ret = this._notify(c, args, ce);
          } else {
              try {
                  ret = this._notify(c, args, ce);
              } catch (e) {
                  Y.error(this + ' failed: ' + e.message, e);
              }
          }
  
          return ret;
      },
  
      /**
       * Returns true if the fn and obj match this objects properties.
       * Used by the unsubscribe method to match the right subscriber.
       *
       * @method contains
       * @param {Function} fn the function to execute.
       * @param {Object} context optional 'this' keyword for the listener.
       * @return {boolean} true if the supplied arguments match this
       *                   subscriber's signature.
       */
      contains: function(fn, context) {
          if (context) {
              return ((this.fn == fn) && this.context == context);
          } else {
              return (this.fn == fn);
          }
      }
  
  };
  /**
   * Return value from all subscribe operations
   * @class EventHandle
   * @constructor
   * @param {CustomEvent} evt the custom event.
   * @param {Subscriber} sub the subscriber.
   */
  Y.EventHandle = function(evt, sub) {
  
      /**
       * The custom event
       *
       * @property evt
       * @type CustomEvent
       */
      this.evt = evt;
  
      /**
       * The subscriber object
       *
       * @property sub
       * @type Subscriber
       */
      this.sub = sub;
  };
  
  Y.EventHandle.prototype = {
      batch: function(f, c) {
          f.call(c || this, this);
          if (Y.Lang.isArray(this.evt)) {
              Y.Array.each(this.evt, function(h) {
                  h.batch.call(c || h, f);
              });
          }
      },
  
      /**
       * Detaches this subscriber
       * @method detach
       * @return {int} the number of detached listeners
       */
      detach: function() {
          var evt = this.evt, detached = 0, i;
          if (evt) {
              if (Y.Lang.isArray(evt)) {
                  for (i = 0; i < evt.length; i++) {
                      detached += evt[i].detach();
                  }
              } else {
                  evt._delete(this.sub);
                  detached = 1;
              }
  
          }
  
          return detached;
      },
  
      /**
       * Monitor the event state for the subscribed event.  The first parameter
       * is what should be monitored, the rest are the normal parameters when
       * subscribing to an event.
       * @method monitor
       * @param what {string} what to monitor ('attach', 'detach', 'publish').
       * @return {EventHandle} return value from the monitor event subscription.
       */
      monitor: function(what) {
          return this.evt.monitor.apply(this.evt, arguments);
      }
  };
  
  /**
   * Custom event engine, DOM event listener abstraction layer, synthetic DOM
   * events.
   * @module event-custom
   * @submodule event-custom-base
   */
  
  /**
   * EventTarget provides the implementation for any object to
   * publish, subscribe and fire to custom events, and also
   * alows other EventTargets to target the object with events
   * sourced from the other object.
   * EventTarget is designed to be used with Y.augment to wrap
   * EventCustom in an interface that allows events to be listened to
   * and fired by name.  This makes it possible for implementing code to
   * subscribe to an event that either has not been created yet, or will
   * not be created at all.
   * @class EventTarget
   * @param opts a configuration object
   * @config emitFacade {boolean} if true, all events will emit event
   * facade payloads by default (default false)
   * @config prefix {String} the prefix to apply to non-prefixed event names
   */
  
  var L = Y.Lang,
      PREFIX_DELIMITER = ':',
      CATEGORY_DELIMITER = '|',
      AFTER_PREFIX = '~AFTER~',
      YArray = Y.Array,
  
      _wildType = Y.cached(function(type) {
          return type.replace(/(.*)(:)(.*)/, "*$2$3");
      }),
  
      /**
       * If the instance has a prefix attribute and the
       * event type is not prefixed, the instance prefix is
       * applied to the supplied type.
       * @method _getType
       * @private
       */
      _getType = Y.cached(function(type, pre) {
  
          if (!pre || !L.isString(type) || type.indexOf(PREFIX_DELIMITER) > -1) {
              return type;
          }
  
          return pre + PREFIX_DELIMITER + type;
      }),
  
      /**
       * Returns an array with the detach key (if provided),
       * and the prefixed event name from _getType
       * Y.on('detachcategory| menu:click', fn)
       * @method _parseType
       * @private
       */
      _parseType = Y.cached(function(type, pre) {
  
          var t = type, detachcategory, after, i;
  
          if (!L.isString(t)) {
              return t;
          }
  
          i = t.indexOf(AFTER_PREFIX);
  
          if (i > -1) {
              after = true;
              t = t.substr(AFTER_PREFIX.length);
          }
  
          i = t.indexOf(CATEGORY_DELIMITER);
  
          if (i > -1) {
              detachcategory = t.substr(0, (i));
              t = t.substr(i+1);
              if (t == '*') {
                  t = null;
              }
          }
  
          // detach category, full type with instance prefix, is this an after listener, short type
          return [detachcategory, (pre) ? _getType(t, pre) : t, after, t];
      }),
  
      ET = function(opts) {
  
  
          var o = (L.isObject(opts)) ? opts : {};
  
          this._yuievt = this._yuievt || {
  
              id: Y.guid(),
  
              events: {},
  
              targets: {},
  
              config: o,
  
              chain: ('chain' in o) ? o.chain : Y.config.chain,
  
              bubbling: false,
  
              defaults: {
                  context: o.context || this,
                  host: this,
                  emitFacade: o.emitFacade,
                  fireOnce: o.fireOnce,
                  queuable: o.queuable,
                  monitored: o.monitored,
                  broadcast: o.broadcast,
                  defaultTargetOnly: o.defaultTargetOnly,
                  bubbles: ('bubbles' in o) ? o.bubbles : true
              }
          };
  
      };
  
  
  ET.prototype = {
      constructor: ET,
  
      /**
       * Listen to a custom event hosted by this object one time.
       * This is the equivalent to <code>on</code> except the
       * listener is immediatelly detached when it is executed.
       * @method once
       * @param {String} type The name of the event
       * @param {Function} fn The callback to execute in response to the event
       * @param {Object} [context] Override `this` object in callback
       * @param {Any} [arg*] 0..n additional arguments to supply to the subscriber
       * @return {EventHandle} A subscription handle capable of detaching the
       *                       subscription
       */
      once: function() {
          var handle = this.on.apply(this, arguments);
          handle.batch(function(hand) {
              if (hand.sub) {
                  hand.sub.once = true;
              }
          });
          return handle;
      },
  
      /**
       * Listen to a custom event hosted by this object one time.
       * This is the equivalent to <code>after</code> except the
       * listener is immediatelly detached when it is executed.
       * @method onceAfter
       * @param {String} type The name of the event
       * @param {Function} fn The callback to execute in response to the event
       * @param {Object} [context] Override `this` object in callback
       * @param {Any} [arg*] 0..n additional arguments to supply to the subscriber
       * @return {EventHandle} A subscription handle capable of detaching that
       *                       subscription
       */
      onceAfter: function() {
          var handle = this.after.apply(this, arguments);
          handle.batch(function(hand) {
              if (hand.sub) {
                  hand.sub.once = true;
              }
          });
          return handle;
      },
  
      /**
       * Takes the type parameter passed to 'on' and parses out the
       * various pieces that could be included in the type.  If the
       * event type is passed without a prefix, it will be expanded
       * to include the prefix one is supplied or the event target
       * is configured with a default prefix.
       * @method parseType
       * @param {String} type the type
       * @param {String} [pre=this._yuievt.config.prefix] the prefix
       * @since 3.3.0
       * @return {Array} an array containing:
       *  * the detach category, if supplied,
       *  * the prefixed event type,
       *  * whether or not this is an after listener,
       *  * the supplied event type
       */
      parseType: function(type, pre) {
          return _parseType(type, pre || this._yuievt.config.prefix);
      },
  
      /**
       * Subscribe a callback function to a custom event fired by this object or
       * from an object that bubbles its events to this object.
       *
       * Callback functions for events published with `emitFacade = true` will
       * receive an `EventFacade` as the first argument (typically named "e").
       * These callbacks can then call `e.preventDefault()` to disable the
       * behavior published to that event's `defaultFn`.  See the `EventFacade`
       * API for all available properties and methods. Subscribers to
       * non-`emitFacade` events will receive the arguments passed to `fire()`
       * after the event name.
       *
       * To subscribe to multiple events at once, pass an object as the first
       * argument, where the key:value pairs correspond to the eventName:callback,
       * or pass an array of event names as the first argument to subscribe to
       * all listed events with the same callback.
       *
       * Returning `false` from a callback is supported as an alternative to
       * calling `e.preventDefault(); e.stopPropagation();`.  However, it is
       * recommended to use the event methods whenever possible.
       *
       * @method on
       * @param {String} type The name of the event
       * @param {Function} fn The callback to execute in response to the event
       * @param {Object} [context] Override `this` object in callback
       * @param {Any} [arg*] 0..n additional arguments to supply to the subscriber
       * @return {EventHandle} A subscription handle capable of detaching that
       *                       subscription
       */
      on: function(type, fn, context) {
  
          var parts = _parseType(type, this._yuievt.config.prefix), f, c, args, ret, ce,
              detachcategory, handle, store = Y.Env.evt.handles, after, adapt, shorttype,
              Node = Y.Node, n, domevent, isArr;
  
          // full name, args, detachcategory, after
          this._monitor('attach', parts[1], {
              args: arguments,
              category: parts[0],
              after: parts[2]
          });
  
          if (L.isObject(type)) {
  
              if (L.isFunction(type)) {
                  return Y.Do.before.apply(Y.Do, arguments);
              }
  
              f = fn;
              c = context;
              args = YArray(arguments, 0, true);
              ret = [];
  
              if (L.isArray(type)) {
                  isArr = true;
              }
  
              after = type._after;
              delete type._after;
  
              Y.each(type, function(v, k) {
  
                  if (L.isObject(v)) {
                      f = v.fn || ((L.isFunction(v)) ? v : f);
                      c = v.context || c;
                  }
  
                  var nv = (after) ? AFTER_PREFIX : '';
  
                  args[0] = nv + ((isArr) ? v : k);
                  args[1] = f;
                  args[2] = c;
  
                  ret.push(this.on.apply(this, args));
  
              }, this);
  
              return (this._yuievt.chain) ? this : new Y.EventHandle(ret);
  
          }
  
          detachcategory = parts[0];
          after = parts[2];
          shorttype = parts[3];
  
          // extra redirection so we catch adaptor events too.  take a look at this.
          if (Node && Y.instanceOf(this, Node) && (shorttype in Node.DOM_EVENTS)) {
              args = YArray(arguments, 0, true);
              args.splice(2, 0, Node.getDOMNode(this));
              return Y.on.apply(Y, args);
          }
  
          type = parts[1];
  
          if (Y.instanceOf(this, YUI)) {
  
              adapt = Y.Env.evt.plugins[type];
              args  = YArray(arguments, 0, true);
              args[0] = shorttype;
  
              if (Node) {
                  n = args[2];
  
                  if (Y.instanceOf(n, Y.NodeList)) {
                      n = Y.NodeList.getDOMNodes(n);
                  } else if (Y.instanceOf(n, Node)) {
                      n = Node.getDOMNode(n);
                  }
  
                  domevent = (shorttype in Node.DOM_EVENTS);
  
                  // Captures both DOM events and event plugins.
                  if (domevent) {
                      args[2] = n;
                  }
              }
  
              // check for the existance of an event adaptor
              if (adapt) {
                  handle = adapt.on.apply(Y, args);
              } else if ((!type) || domevent) {
                  handle = Y.Event._attach(args);
              }
  
          }
  
          if (!handle) {
              ce = this._yuievt.events[type] || this.publish(type);
              handle = ce._on(fn, context, (arguments.length > 3) ? YArray(arguments, 3, true) : null, (after) ? 'after' : true);
          }
  
          if (detachcategory) {
              store[detachcategory] = store[detachcategory] || {};
              store[detachcategory][type] = store[detachcategory][type] || [];
              store[detachcategory][type].push(handle);
          }
  
          return (this._yuievt.chain) ? this : handle;
  
      },
  
      /**
       * subscribe to an event
       * @method subscribe
       * @deprecated use on
       */
      subscribe: function() {
          return this.on.apply(this, arguments);
      },
  
      /**
       * Detach one or more listeners the from the specified event
       * @method detach
       * @param type {string|Object}   Either the handle to the subscriber or the
       *                        type of event.  If the type
       *                        is not specified, it will attempt to remove
       *                        the listener from all hosted events.
       * @param fn   {Function} The subscribed function to unsubscribe, if not
       *                          supplied, all subscribers will be removed.
       * @param context  {Object}   The custom object passed to subscribe.  This is
       *                        optional, but if supplied will be used to
       *                        disambiguate multiple listeners that are the same
       *                        (e.g., you subscribe many object using a function
       *                        that lives on the prototype)
       * @return {EventTarget} the host
       */
      detach: function(type, fn, context) {
          var evts = this._yuievt.events, i,
              Node = Y.Node, isNode = Node && (Y.instanceOf(this, Node));
  
          // detachAll disabled on the Y instance.
          if (!type && (this !== Y)) {
              for (i in evts) {
                  if (evts.hasOwnProperty(i)) {
                      evts[i].detach(fn, context);
                  }
              }
              if (isNode) {
                  Y.Event.purgeElement(Node.getDOMNode(this));
              }
  
              return this;
          }
  
          var parts = _parseType(type, this._yuievt.config.prefix),
          detachcategory = L.isArray(parts) ? parts[0] : null,
          shorttype = (parts) ? parts[3] : null,
          adapt, store = Y.Env.evt.handles, detachhost, cat, args,
          ce,
  
          keyDetacher = function(lcat, ltype, host) {
              var handles = lcat[ltype], ce, i;
              if (handles) {
                  for (i = handles.length - 1; i >= 0; --i) {
                      ce = handles[i].evt;
                      if (ce.host === host || ce.el === host) {
                          handles[i].detach();
                      }
                  }
              }
          };
  
          if (detachcategory) {
  
              cat = store[detachcategory];
              type = parts[1];
              detachhost = (isNode) ? Y.Node.getDOMNode(this) : this;
  
              if (cat) {
                  if (type) {
                      keyDetacher(cat, type, detachhost);
                  } else {
                      for (i in cat) {
                          if (cat.hasOwnProperty(i)) {
                              keyDetacher(cat, i, detachhost);
                          }
                      }
                  }
  
                  return this;
              }
  
          // If this is an event handle, use it to detach
          } else if (L.isObject(type) && type.detach) {
              type.detach();
              return this;
          // extra redirection so we catch adaptor events too.  take a look at this.
          } else if (isNode && ((!shorttype) || (shorttype in Node.DOM_EVENTS))) {
              args = YArray(arguments, 0, true);
              args[2] = Node.getDOMNode(this);
              Y.detach.apply(Y, args);
              return this;
          }
  
          adapt = Y.Env.evt.plugins[shorttype];
  
          // The YUI instance handles DOM events and adaptors
          if (Y.instanceOf(this, YUI)) {
              args = YArray(arguments, 0, true);
              // use the adaptor specific detach code if
              if (adapt && adapt.detach) {
                  adapt.detach.apply(Y, args);
                  return this;
              // DOM event fork
              } else if (!type || (!adapt && Node && (type in Node.DOM_EVENTS))) {
                  args[0] = type;
                  Y.Event.detach.apply(Y.Event, args);
                  return this;
              }
          }
  
          // ce = evts[type];
          ce = evts[parts[1]];
          if (ce) {
              ce.detach(fn, context);
          }
  
          return this;
      },
  
      /**
       * detach a listener
       * @method unsubscribe
       * @deprecated use detach
       */
      unsubscribe: function() {
          return this.detach.apply(this, arguments);
      },
  
      /**
       * Removes all listeners from the specified event.  If the event type
       * is not specified, all listeners from all hosted custom events will
       * be removed.
       * @method detachAll
       * @param type {String}   The type, or name of the event
       */
      detachAll: function(type) {
          return this.detach(type);
      },
  
      /**
       * Removes all listeners from the specified event.  If the event type
       * is not specified, all listeners from all hosted custom events will
       * be removed.
       * @method unsubscribeAll
       * @param type {String}   The type, or name of the event
       * @deprecated use detachAll
       */
      unsubscribeAll: function() {
          return this.detachAll.apply(this, arguments);
      },
  
      /**
       * Creates a new custom event of the specified type.  If a custom event
       * by that name already exists, it will not be re-created.  In either
       * case the custom event is returned.
       *
       * @method publish
       *
       * @param type {String} the type, or name of the event
       * @param opts {object} optional config params.  Valid properties are:
       *
       *  <ul>
       *    <li>
       *   'broadcast': whether or not the YUI instance and YUI global are notified when the event is fired (false)
       *    </li>
       *    <li>
       *   'bubbles': whether or not this event bubbles (true)
       *              Events can only bubble if emitFacade is true.
       *    </li>
       *    <li>
       *   'context': the default execution context for the listeners (this)
       *    </li>
       *    <li>
       *   'defaultFn': the default function to execute when this event fires if preventDefault was not called
       *    </li>
       *    <li>
       *   'emitFacade': whether or not this event emits a facade (false)
       *    </li>
       *    <li>
       *   'prefix': the prefix for this targets events, e.g., 'menu' in 'menu:click'
       *    </li>
       *    <li>
       *   'fireOnce': if an event is configured to fire once, new subscribers after
       *   the fire will be notified immediately.
       *    </li>
       *    <li>
       *   'async': fireOnce event listeners will fire synchronously if the event has already
       *    fired unless async is true.
       *    </li>
       *    <li>
       *   'preventable': whether or not preventDefault() has an effect (true)
       *    </li>
       *    <li>
       *   'preventedFn': a function that is executed when preventDefault is called
       *    </li>
       *    <li>
       *   'queuable': whether or not this event can be queued during bubbling (false)
       *    </li>
       *    <li>
       *   'silent': if silent is true, debug messages are not provided for this event.
       *    </li>
       *    <li>
       *   'stoppedFn': a function that is executed when stopPropagation is called
       *    </li>
       *
       *    <li>
       *   'monitored': specifies whether or not this event should send notifications about
       *   when the event has been attached, detached, or published.
       *    </li>
       *    <li>
       *   'type': the event type (valid option if not provided as the first parameter to publish)
       *    </li>
       *  </ul>
       *
       *  @return {CustomEvent} the custom event
       *
       */
      publish: function(type, opts) {
          var events, ce, ret, defaults,
              edata    = this._yuievt,
              pre      = edata.config.prefix;
  
          if (L.isObject(type)) {
              ret = {};
              Y.each(type, function(v, k) {
                  ret[k] = this.publish(k, v || opts);
              }, this);
  
              return ret;
          }
  
          type = (pre) ? _getType(type, pre) : type;
  
          this._monitor('publish', type, {
              args: arguments
          });
  
          events = edata.events;
          ce = events[type];
  
          if (ce) {
  // ce.log("publish applying new config to published event: '"+type+"' exists", 'info', 'event');
              if (opts) {
                  ce.applyConfig(opts, true);
              }
          } else {
  
              defaults = edata.defaults;
  
              // apply defaults
              ce = new Y.CustomEvent(type,
                                    (opts) ? Y.merge(defaults, opts) : defaults);
              events[type] = ce;
          }
  
          // make sure we turn the broadcast flag off if this
          // event was published as a result of bubbling
          // if (opts instanceof Y.CustomEvent) {
            //   events[type].broadcast = false;
          // }
  
          return events[type];
      },
  
      /**
       * This is the entry point for the event monitoring system.
       * You can monitor 'attach', 'detach', 'fire', and 'publish'.
       * When configured, these events generate an event.  click ->
       * click_attach, click_detach, click_publish -- these can
       * be subscribed to like other events to monitor the event
       * system.  Inividual published events can have monitoring
       * turned on or off (publish can't be turned off before it
       * it published) by setting the events 'monitor' config.
       *
       * @method _monitor
       * @param what {String} 'attach', 'detach', 'fire', or 'publish'
       * @param type {String} Name of the event being monitored
       * @param o {Object} Information about the event interaction, such as
       *                  fire() args, subscription category, publish config
       * @private
       */
      _monitor: function(what, type, o) {
          var monitorevt, ce = this.getEvent(type);
          if ((this._yuievt.config.monitored && (!ce || ce.monitored)) || (ce && ce.monitored)) {
              monitorevt = type + '_' + what;
              o.monitored = what;
              this.fire.call(this, monitorevt, o);
          }
      },
  
     /**
       * Fire a custom event by name.  The callback functions will be executed
       * from the context specified when the event was created, and with the
       * following parameters.
       *
       * If the custom event object hasn't been created, then the event hasn't
       * been published and it has no subscribers.  For performance sake, we
       * immediate exit in this case.  This means the event won't bubble, so
       * if the intention is that a bubble target be notified, the event must
       * be published on this object first.
       *
       * The first argument is the event type, and any additional arguments are
       * passed to the listeners as parameters.  If the first of these is an
       * object literal, and the event is configured to emit an event facade,
       * that object is mixed into the event facade and the facade is provided
       * in place of the original object.
       *
       * @method fire
       * @param type {String|Object} The type of the event, or an object that contains
       * a 'type' property.
       * @param arguments {Object*} an arbitrary set of parameters to pass to
       * the handler.  If the first of these is an object literal and the event is
       * configured to emit an event facade, the event facade will replace that
       * parameter after the properties the object literal contains are copied to
       * the event facade.
       * @return {EventTarget} the event host
       *
       */
      fire: function(type) {
  
          var typeIncluded = L.isString(type),
              t = (typeIncluded) ? type : (type && type.type),
              ce, ret, pre = this._yuievt.config.prefix, ce2,
              args = (typeIncluded) ? YArray(arguments, 1, true) : arguments;
  
          t = (pre) ? _getType(t, pre) : t;
  
          this._monitor('fire', t, {
              args: args
          });
  
          ce = this.getEvent(t, true);
          ce2 = this.getSibling(t, ce);
  
          if (ce2 && !ce) {
              ce = this.publish(t);
          }
  
          // this event has not been published or subscribed to
          if (!ce) {
              if (this._yuievt.hasTargets) {
                  return this.bubble({ type: t }, args, this);
              }
  
              // otherwise there is nothing to be done
              ret = true;
          } else {
              ce.sibling = ce2;
              ret = ce.fire.apply(ce, args);
          }
  
          return (this._yuievt.chain) ? this : ret;
      },
  
      getSibling: function(type, ce) {
          var ce2;
          // delegate to *:type events if there are subscribers
          if (type.indexOf(PREFIX_DELIMITER) > -1) {
              type = _wildType(type);
              // console.log(type);
              ce2 = this.getEvent(type, true);
              if (ce2) {
                  // console.log("GOT ONE: " + type);
                  ce2.applyConfig(ce);
                  ce2.bubbles = false;
                  ce2.broadcast = 0;
                  // ret = ce2.fire.apply(ce2, a);
              }
          }
  
          return ce2;
      },
  
      /**
       * Returns the custom event of the provided type has been created, a
       * falsy value otherwise
       * @method getEvent
       * @param type {String} the type, or name of the event
       * @param prefixed {String} if true, the type is prefixed already
       * @return {CustomEvent} the custom event or null
       */
      getEvent: function(type, prefixed) {
          var pre, e;
          if (!prefixed) {
              pre = this._yuievt.config.prefix;
              type = (pre) ? _getType(type, pre) : type;
          }
          e = this._yuievt.events;
          return e[type] || null;
      },
  
      /**
       * Subscribe to a custom event hosted by this object.  The
       * supplied callback will execute after any listeners add
       * via the subscribe method, and after the default function,
       * if configured for the event, has executed.
       *
       * @method after
       * @param {String} type The name of the event
       * @param {Function} fn The callback to execute in response to the event
       * @param {Object} [context] Override `this` object in callback
       * @param {Any} [arg*] 0..n additional arguments to supply to the subscriber
       * @return {EventHandle} A subscription handle capable of detaching the
       *                       subscription
       */
      after: function(type, fn) {
  
          var a = YArray(arguments, 0, true);
  
          switch (L.type(type)) {
              case 'function':
                  return Y.Do.after.apply(Y.Do, arguments);
              case 'array':
              //     YArray.each(a[0], function(v) {
              //         v = AFTER_PREFIX + v;
              //     });
              //     break;
              case 'object':
                  a[0]._after = true;
                  break;
              default:
                  a[0] = AFTER_PREFIX + type;
          }
  
          return this.on.apply(this, a);
  
      },
  
      /**
       * Executes the callback before a DOM event, custom event
       * or method.  If the first argument is a function, it
       * is assumed the target is a method.  For DOM and custom
       * events, this is an alias for Y.on.
       *
       * For DOM and custom events:
       * type, callback, context, 0-n arguments
       *
       * For methods:
       * callback, object (method host), methodName, context, 0-n arguments
       *
       * @method before
       * @return detach handle
       */
      before: function() {
          return this.on.apply(this, arguments);
      }
  
  };
  
  Y.EventTarget = ET;
  
  // make Y an event target
  Y.mix(Y, ET.prototype);
  ET.call(Y, { bubbles: false });
  
  YUI.Env.globalEvents = YUI.Env.globalEvents || new ET();
  
  /**
   * Hosts YUI page level events.  This is where events bubble to
   * when the broadcast config is set to 2.  This property is
   * only available if the custom event module is loaded.
   * @property Global
   * @type EventTarget
   * @for YUI
   */
  Y.Global = YUI.Env.globalEvents;
  
  // @TODO implement a global namespace function on Y.Global?
  
  /**
  `Y.on()` can do many things:
  
  <ul>
      <li>Subscribe to custom events `publish`ed and `fire`d from Y</li>
      <li>Subscribe to custom events `publish`ed with `broadcast` 1 or 2 and
          `fire`d from any object in the YUI instance sandbox</li>
      <li>Subscribe to DOM events</li>
      <li>Subscribe to the execution of a method on any object, effectively
      treating that method as an event</li>
  </ul>
  
  For custom event subscriptions, pass the custom event name as the first argument and callback as the second. The `this` object in the callback will be `Y` unless an override is passed as the third argument.
  
      Y.on('io:complete', function () {
          Y.MyApp.updateStatus('Transaction complete');
      });
  
  To subscribe to DOM events, pass the name of a DOM event as the first argument
  and a CSS selector string as the third argument after the callback function.
  Alternately, the third argument can be a `Node`, `NodeList`, `HTMLElement`,
  array, or simply omitted (the default is the `window` object).
  
      Y.on('click', function (e) {
          e.preventDefault();
  
          // proceed with ajax form submission
          var url = this.get('action');
          ...
      }, '#my-form');
  
  The `this` object in DOM event callbacks will be the `Node` targeted by the CSS
  selector or other identifier.
  
  `on()` subscribers for DOM events or custom events `publish`ed with a
  `defaultFn` can prevent the default behavior with `e.preventDefault()` from the
  event object passed as the first parameter to the subscription callback.
  
  To subscribe to the execution of an object method, pass arguments corresponding to the call signature for 
  <a href="../classes/Do.html#methods_before">`Y.Do.before(...)`</a>.
  
  NOTE: The formal parameter list below is for events, not for function
  injection.  See `Y.Do.before` for that signature.
  
  @method on
  @param {String} type DOM or custom event name
  @param {Function} fn The callback to execute in response to the event
  @param {Object} [context] Override `this` object in callback
  @param {Any} [arg*] 0..n additional arguments to supply to the subscriber
  @return {EventHandle} A subscription handle capable of detaching the
                        subscription
  @see Do.before
  @for YUI
  **/
  
  /**
  Listen for an event one time.  Equivalent to `on()`, except that
  the listener is immediately detached when executed.
  
  See the <a href="#methods_on">`on()` method</a> for additional subscription
  options.
  
  @see on
  @method once
  @param {String} type DOM or custom event name
  @param {Function} fn The callback to execute in response to the event
  @param {Object} [context] Override `this` object in callback
  @param {Any} [arg*] 0..n additional arguments to supply to the subscriber
  @return {EventHandle} A subscription handle capable of detaching the
                        subscription
  @for YUI
  **/
  
  /**
  Listen for an event one time.  Equivalent to `once()`, except, like `after()`,
  the subscription callback executes after all `on()` subscribers and the event's
  `defaultFn` (if configured) have executed.  Like `after()` if any `on()` phase
  subscriber calls `e.preventDefault()`, neither the `defaultFn` nor the `after()`
  subscribers will execute.
  
  The listener is immediately detached when executed.
  
  See the <a href="#methods_on">`on()` method</a> for additional subscription
  options.
  
  @see once
  @method onceAfter
  @param {String} type The custom event name
  @param {Function} fn The callback to execute in response to the event
  @param {Object} [context] Override `this` object in callback
  @param {Any} [arg*] 0..n additional arguments to supply to the subscriber
  @return {EventHandle} A subscription handle capable of detaching the
                        subscription
  @for YUI
  **/
  
  /**
  Like `on()`, this method creates a subscription to a custom event or to the
  execution of a method on an object.
  
  For events, `after()` subscribers are executed after the event's
  `defaultFn` unless `e.preventDefault()` was called from an `on()` subscriber.
  
  See the <a href="#methods_on">`on()` method</a> for additional subscription
  options.
  
  NOTE: The subscription signature shown is for events, not for function
  injection.  See <a href="../classes/Do.html#methods_after">`Y.Do.after`</a>
  for that signature.
  
  @see on
  @see Do.after
  @method after
  @param {String} type The custom event name
  @param {Function} fn The callback to execute in response to the event
  @param {Object} [context] Override `this` object in callback
  @param {Any} [args*] 0..n additional arguments to supply to the subscriber
  @return {EventHandle} A subscription handle capable of detaching the
                        subscription
  @for YUI
  **/
  
  
  }, '@VERSION@' ,{requires:['oop']});
  YUI.add('event-custom-complex', function(Y) {
  
  
  /**
   * Adds event facades, preventable default behavior, and bubbling.
   * events.
   * @module event-custom
   * @submodule event-custom-complex
   */
  
  var FACADE,
      FACADE_KEYS,
      EMPTY = {},
      CEProto = Y.CustomEvent.prototype,
      ETProto = Y.EventTarget.prototype;
  
  /**
   * Wraps and protects a custom event for use when emitFacade is set to true.
   * Requires the event-custom-complex module
   * @class EventFacade
   * @param e {Event} the custom event
   * @param currentTarget {HTMLElement} the element the listener was attached to
   */
  
  Y.EventFacade = function(e, currentTarget) {
  
      e = e || EMPTY;
  
      this._event = e;
  
      /**
       * The arguments passed to fire
       * @property details
       * @type Array
       */
      this.details = e.details;
  
      /**
       * The event type, this can be overridden by the fire() payload
       * @property type
       * @type string
       */
      this.type = e.type;
  
      /**
       * The real event type
       * @property _type
       * @type string
       * @private
       */
      this._type = e.type;
  
      //////////////////////////////////////////////////////
  
      /**
       * Node reference for the targeted eventtarget
       * @property target
       * @type Node
       */
      this.target = e.target;
  
      /**
       * Node reference for the element that the listener was attached to.
       * @property currentTarget
       * @type Node
       */
      this.currentTarget = currentTarget;
  
      /**
       * Node reference to the relatedTarget
       * @property relatedTarget
       * @type Node
       */
      this.relatedTarget = e.relatedTarget;
  
  };
  
  Y.extend(Y.EventFacade, Object, {
  
      /**
       * Stops the propagation to the next bubble target
       * @method stopPropagation
       */
      stopPropagation: function() {
          this._event.stopPropagation();
          this.stopped = 1;
      },
  
      /**
       * Stops the propagation to the next bubble target and
       * prevents any additional listeners from being exectued
       * on the current target.
       * @method stopImmediatePropagation
       */
      stopImmediatePropagation: function() {
          this._event.stopImmediatePropagation();
          this.stopped = 2;
      },
  
      /**
       * Prevents the event's default behavior
       * @method preventDefault
       */
      preventDefault: function() {
          this._event.preventDefault();
          this.prevented = 1;
      },
  
      /**
       * Stops the event propagation and prevents the default
       * event behavior.
       * @method halt
       * @param immediate {boolean} if true additional listeners
       * on the current target will not be executed
       */
      halt: function(immediate) {
          this._event.halt(immediate);
          this.prevented = 1;
          this.stopped = (immediate) ? 2 : 1;
      }
  
  });
  
  CEProto.fireComplex = function(args) {
  
      var es, ef, q, queue, ce, ret, events, subs, postponed,
          self = this, host = self.host || self, next, oldbubble;
  
      if (self.stack) {
          // queue this event if the current item in the queue bubbles
          if (self.queuable && self.type != self.stack.next.type) {
              self.log('queue ' + self.type);
              self.stack.queue.push([self, args]);
              return true;
          }
      }
  
      es = self.stack || {
         // id of the first event in the stack
         id: self.id,
         next: self,
         silent: self.silent,
         stopped: 0,
         prevented: 0,
         bubbling: null,
         type: self.type,
         // defaultFnQueue: new Y.Queue(),
         afterQueue: new Y.Queue(),
         defaultTargetOnly: self.defaultTargetOnly,
         queue: []
      };
  
      subs = self.getSubs();
  
      self.stopped = (self.type !== es.type) ? 0 : es.stopped;
      self.prevented = (self.type !== es.type) ? 0 : es.prevented;
  
      self.target = self.target || host;
  
      events = new Y.EventTarget({
          fireOnce: true,
          context: host
      });
  
      self.events = events;
  
      if (self.stoppedFn) {
          events.on('stopped', self.stoppedFn);
      }
  
      self.currentTarget = host;
  
      self.details = args.slice(); // original arguments in the details
  
      // self.log("Firing " + self  + ", " + "args: " + args);
      self.log("Firing " + self.type);
  
      self._facade = null; // kill facade to eliminate stale properties
  
      ef = self._getFacade(args);
  
      if (Y.Lang.isObject(args[0])) {
          args[0] = ef;
      } else {
          args.unshift(ef);
      }
  
      // if (subCount) {
      if (subs[0]) {
          // self._procSubs(Y.merge(self.subscribers), args, ef);
          self._procSubs(subs[0], args, ef);
      }
  
      // bubble if this is hosted in an event target and propagation has not been stopped
      if (self.bubbles && host.bubble && !self.stopped) {
  
          oldbubble = es.bubbling;
  
          // self.bubbling = true;
          es.bubbling = self.type;
  
          // if (host !== ef.target || es.type != self.type) {
          if (es.type != self.type) {
              es.stopped = 0;
              es.prevented = 0;
          }
  
          ret = host.bubble(self, args, null, es);
  
          self.stopped = Math.max(self.stopped, es.stopped);
          self.prevented = Math.max(self.prevented, es.prevented);
  
          // self.bubbling = false;
          es.bubbling = oldbubble;
  
      }
  
      if (self.prevented) {
          if (self.preventedFn) {
              self.preventedFn.apply(host, args);
          }
      } else if (self.defaultFn &&
                ((!self.defaultTargetOnly && !es.defaultTargetOnly) ||
                  host === ef.target)) {
          self.defaultFn.apply(host, args);
      }
  
      // broadcast listeners are fired as discreet events on the
      // YUI instance and potentially the YUI global.
      self._broadcast(args);
  
      // Queue the after
      if (subs[1] && !self.prevented && self.stopped < 2) {
          if (es.id === self.id || self.type != host._yuievt.bubbling) {
              self._procSubs(subs[1], args, ef);
              while ((next = es.afterQueue.last())) {
                  next();
              }
          } else {
              postponed = subs[1];
              if (es.execDefaultCnt) {
                  postponed = Y.merge(postponed);
                  Y.each(postponed, function(s) {
                      s.postponed = true;
                  });
              }
  
              es.afterQueue.add(function() {
                  self._procSubs(postponed, args, ef);
              });
          }
      }
  
      self.target = null;
  
      if (es.id === self.id) {
          queue = es.queue;
  
          while (queue.length) {
              q = queue.pop();
              ce = q[0];
              // set up stack to allow the next item to be processed
              es.next = ce;
              ce.fire.apply(ce, q[1]);
          }
  
          self.stack = null;
      }
  
      ret = !(self.stopped);
  
      if (self.type != host._yuievt.bubbling) {
          es.stopped = 0;
          es.prevented = 0;
          self.stopped = 0;
          self.prevented = 0;
      }
  
      return ret;
  };
  
  CEProto._getFacade = function() {
  
      var ef = this._facade, o, o2,
      args = this.details;
  
      if (!ef) {
          ef = new Y.EventFacade(this, this.currentTarget);
      }
  
      // if the first argument is an object literal, apply the
      // properties to the event facade
      o = args && args[0];
  
      if (Y.Lang.isObject(o, true)) {
  
          o2 = {};
  
          // protect the event facade properties
          Y.mix(o2, ef, true, FACADE_KEYS);
  
          // mix the data
          Y.mix(ef, o, true);
  
          // restore ef
          Y.mix(ef, o2, true, FACADE_KEYS);
  
          // Allow the event type to be faked
          // http://yuilibrary.com/projects/yui3/ticket/2528376
          ef.type = o.type || ef.type;
      }
  
      // update the details field with the arguments
      // ef.type = this.type;
      ef.details = this.details;
  
      // use the original target when the event bubbled to this target
      ef.target = this.originalTarget || this.target;
  
      ef.currentTarget = this.currentTarget;
      ef.stopped = 0;
      ef.prevented = 0;
  
      this._facade = ef;
  
      return this._facade;
  };
  
  /**
   * Stop propagation to bubble targets
   * @for CustomEvent
   * @method stopPropagation
   */
  CEProto.stopPropagation = function() {
      this.stopped = 1;
      if (this.stack) {
          this.stack.stopped = 1;
      }
      this.events.fire('stopped', this);
  };
  
  /**
   * Stops propagation to bubble targets, and prevents any remaining
   * subscribers on the current target from executing.
   * @method stopImmediatePropagation
   */
  CEProto.stopImmediatePropagation = function() {
      this.stopped = 2;
      if (this.stack) {
          this.stack.stopped = 2;
      }
      this.events.fire('stopped', this);
  };
  
  /**
   * Prevents the execution of this event's defaultFn
   * @method preventDefault
   */
  CEProto.preventDefault = function() {
      if (this.preventable) {
          this.prevented = 1;
          if (this.stack) {
              this.stack.prevented = 1;
          }
      }
  };
  
  /**
   * Stops the event propagation and prevents the default
   * event behavior.
   * @method halt
   * @param immediate {boolean} if true additional listeners
   * on the current target will not be executed
   */
  CEProto.halt = function(immediate) {
      if (immediate) {
          this.stopImmediatePropagation();
      } else {
          this.stopPropagation();
      }
      this.preventDefault();
  };
  
  /**
   * Registers another EventTarget as a bubble target.  Bubble order
   * is determined by the order registered.  Multiple targets can
   * be specified.
   *
   * Events can only bubble if emitFacade is true.
   *
   * Included in the event-custom-complex submodule.
   *
   * @method addTarget
   * @param o {EventTarget} the target to add
   * @for EventTarget
   */
  ETProto.addTarget = function(o) {
      this._yuievt.targets[Y.stamp(o)] = o;
      this._yuievt.hasTargets = true;
  };
  
  /**
   * Returns an array of bubble targets for this object.
   * @method getTargets
   * @return EventTarget[]
   */
  ETProto.getTargets = function() {
      return Y.Object.values(this._yuievt.targets);
  };
  
  /**
   * Removes a bubble target
   * @method removeTarget
   * @param o {EventTarget} the target to remove
   * @for EventTarget
   */
  ETProto.removeTarget = function(o) {
      delete this._yuievt.targets[Y.stamp(o)];
  };
  
  /**
   * Propagate an event.  Requires the event-custom-complex module.
   * @method bubble
   * @param evt {CustomEvent} the custom event to propagate
   * @return {boolean} the aggregated return value from Event.Custom.fire
   * @for EventTarget
   */
  ETProto.bubble = function(evt, args, target, es) {
  
      var targs = this._yuievt.targets, ret = true,
          t, type = evt && evt.type, ce, i, bc, ce2,
          originalTarget = target || (evt && evt.target) || this,
          oldbubble;
  
      if (!evt || ((!evt.stopped) && targs)) {
  
          for (i in targs) {
              if (targs.hasOwnProperty(i)) {
                  t = targs[i];
                  ce = t.getEvent(type, true);
                  ce2 = t.getSibling(type, ce);
  
                  if (ce2 && !ce) {
                      ce = t.publish(type);
                  }
  
                  oldbubble = t._yuievt.bubbling;
                  t._yuievt.bubbling = type;
  
                  // if this event was not published on the bubble target,
                  // continue propagating the event.
                  if (!ce) {
                      if (t._yuievt.hasTargets) {
                          t.bubble(evt, args, originalTarget, es);
                      }
                  } else {
  
                      ce.sibling = ce2;
  
                      // set the original target to that the target payload on the
                      // facade is correct.
                      ce.target = originalTarget;
                      ce.originalTarget = originalTarget;
                      ce.currentTarget = t;
                      bc = ce.broadcast;
                      ce.broadcast = false;
  
                      // default publish may not have emitFacade true -- that
                      // shouldn't be what the implementer meant to do
                      ce.emitFacade = true;
  
                      ce.stack = es;
  
                      ret = ret && ce.fire.apply(ce, args || evt.details || []);
                      ce.broadcast = bc;
                      ce.originalTarget = null;
  
  
                      // stopPropagation() was called
                      if (ce.stopped) {
                          break;
                      }
                  }
  
                  t._yuievt.bubbling = oldbubble;
              }
          }
      }
  
      return ret;
  };
  
  FACADE = new Y.EventFacade();
  FACADE_KEYS = Y.Object.keys(FACADE);
  
  
  
  }, '@VERSION@' ,{requires:['event-custom-base']});
  YUI.add('node-core', function(Y) {
  
  /**
   * The Node Utility provides a DOM-like interface for interacting with DOM nodes.
   * @module node
   * @main node
   * @submodule node-core
   */
  
  /**
   * The Node class provides a wrapper for manipulating DOM Nodes.
   * Node properties can be accessed via the set/get methods.
   * Use `Y.one()` to retrieve Node instances.
   *
   * <strong>NOTE:</strong> Node properties are accessed using
   * the <code>set</code> and <code>get</code> methods.
   *
   * @class Node
   * @constructor
   * @param {DOMNode} node the DOM node to be mapped to the Node instance.
   * @uses EventTarget
   */
  
  // "globals"
  var DOT = '.',
      NODE_NAME = 'nodeName',
      NODE_TYPE = 'nodeType',
      OWNER_DOCUMENT = 'ownerDocument',
      TAG_NAME = 'tagName',
      UID = '_yuid',
      EMPTY_OBJ = {},
  
      _slice = Array.prototype.slice,
  
      Y_DOM = Y.DOM,
  
      Y_Node = function(node) {
          if (!this.getDOMNode) { // support optional "new"
              return new Y_Node(node);
          }
  
          if (typeof node == 'string') {
              node = Y_Node._fromString(node);
              if (!node) {
                  return null; // NOTE: return
              }
          }
  
          var uid = (node.nodeType !== 9) ? node.uniqueID : node[UID];
  
          if (uid && Y_Node._instances[uid] && Y_Node._instances[uid]._node !== node) {
              node[UID] = null; // unset existing uid to prevent collision (via clone or hack)
          }
  
          uid = uid || Y.stamp(node);
          if (!uid) { // stamp failed; likely IE non-HTMLElement
              uid = Y.guid();
          }
  
          this[UID] = uid;
  
          /**
           * The underlying DOM node bound to the Y.Node instance
           * @property _node
           * @type DOMNode
           * @private
           */
          this._node = node;
  
          this._stateProxy = node; // when augmented with Attribute
  
          if (this._initPlugins) { // when augmented with Plugin.Host
              this._initPlugins();
          }
      },
  
      // used with previous/next/ancestor tests
      _wrapFn = function(fn) {
          var ret = null;
          if (fn) {
              ret = (typeof fn == 'string') ?
              function(n) {
                  return Y.Selector.test(n, fn);
              } :
              function(n) {
                  return fn(Y.one(n));
              };
          }
  
          return ret;
      };
  // end "globals"
  
  Y_Node.ATTRS = {};
  Y_Node.DOM_EVENTS = {};
  
  Y_Node._fromString = function(node) {
      if (node) {
          if (node.indexOf('doc') === 0) { // doc OR document
              node = Y.config.doc;
          } else if (node.indexOf('win') === 0) { // win OR window
              node = Y.config.win;
          } else {
              node = Y.Selector.query(node, null, true);
          }
      }
  
      return node || null;
  };
  
  /**
   * The name of the component
   * @static
   * @type String
   * @property NAME
   */
  Y_Node.NAME = 'node';
  
  /*
   * The pattern used to identify ARIA attributes
   */
  Y_Node.re_aria = /^(?:role$|aria-)/;
  
  Y_Node.SHOW_TRANSITION = 'fadeIn';
  Y_Node.HIDE_TRANSITION = 'fadeOut';
  
  /**
   * A list of Node instances that have been created
   * @private
   * @type Object
   * @property _instances
   * @static
   *
   */
  Y_Node._instances = {};
  
  /**
   * Retrieves the DOM node bound to a Node instance
   * @method getDOMNode
   * @static
   *
   * @param {Node | HTMLNode} node The Node instance or an HTMLNode
   * @return {HTMLNode} The DOM node bound to the Node instance.  If a DOM node is passed
   * as the node argument, it is simply returned.
   */
  Y_Node.getDOMNode = function(node) {
      if (node) {
          return (node.nodeType) ? node : node._node || null;
      }
      return null;
  };
  
  /**
   * Checks Node return values and wraps DOM Nodes as Y.Node instances
   * and DOM Collections / Arrays as Y.NodeList instances.
   * Other return values just pass thru.  If undefined is returned (e.g. no return)
   * then the Node instance is returned for chainability.
   * @method scrubVal
   * @static
   *
   * @param {any} node The Node instance or an HTMLNode
   * @return {Node | NodeList | Any} Depends on what is returned from the DOM node.
   */
  Y_Node.scrubVal = function(val, node) {
      if (val) { // only truthy values are risky
           if (typeof val == 'object' || typeof val == 'function') { // safari nodeList === function
              if (NODE_TYPE in val || Y_DOM.isWindow(val)) {// node || window
                  val = Y.one(val);
              } else if ((val.item && !val._nodes) || // dom collection or Node instance
                      (val[0] && val[0][NODE_TYPE])) { // array of DOM Nodes
                  val = Y.all(val);
              }
          }
      } else if (typeof val === 'undefined') {
          val = node; // for chaining
      } else if (val === null) {
          val = null; // IE: DOM null not the same as null
      }
  
      return val;
  };
  
  /**
   * Adds methods to the Y.Node prototype, routing through scrubVal.
   * @method addMethod
   * @static
   *
   * @param {String} name The name of the method to add
   * @param {Function} fn The function that becomes the method
   * @param {Object} context An optional context to call the method with
   * (defaults to the Node instance)
   * @return {any} Depends on what is returned from the DOM node.
   */
  Y_Node.addMethod = function(name, fn, context) {
      if (name && fn && typeof fn == 'function') {
          Y_Node.prototype[name] = function() {
              var args = _slice.call(arguments),
                  node = this,
                  ret;
  
              if (args[0] && args[0]._node) {
                  args[0] = args[0]._node;
              }
  
              if (args[1] && args[1]._node) {
                  args[1] = args[1]._node;
              }
              args.unshift(node._node);
  
              ret = fn.apply(node, args);
  
              if (ret) { // scrub truthy
                  ret = Y_Node.scrubVal(ret, node);
              }
  
              (typeof ret != 'undefined') || (ret = node);
              return ret;
          };
      } else {
      }
  };
  
  /**
   * Imports utility methods to be added as Y.Node methods.
   * @method importMethod
   * @static
   *
   * @param {Object} host The object that contains the method to import.
   * @param {String} name The name of the method to import
   * @param {String} altName An optional name to use in place of the host name
   * @param {Object} context An optional context to call the method with
   */
  Y_Node.importMethod = function(host, name, altName) {
      if (typeof name == 'string') {
          altName = altName || name;
          Y_Node.addMethod(altName, host[name], host);
      } else {
          Y.Array.each(name, function(n) {
              Y_Node.importMethod(host, n);
          });
      }
  };
  
  /**
   * Retrieves a NodeList based on the given CSS selector.
   * @method all
   *
   * @param {string} selector The CSS selector to test against.
   * @return {NodeList} A NodeList instance for the matching HTMLCollection/Array.
   * @for YUI
   */
  
  /**
   * Returns a single Node instance bound to the node or the
   * first element matching the given selector. Returns null if no match found.
   * <strong>Note:</strong> For chaining purposes you may want to
   * use <code>Y.all</code>, which returns a NodeList when no match is found.
   * @method one
   * @param {String | HTMLElement} node a node or Selector
   * @return {Node | null} a Node instance or null if no match found.
   * @for YUI
   */
  
  /**
   * Returns a single Node instance bound to the node or the
   * first element matching the given selector. Returns null if no match found.
   * <strong>Note:</strong> For chaining purposes you may want to
   * use <code>Y.all</code>, which returns a NodeList when no match is found.
   * @method one
   * @static
   * @param {String | HTMLElement} node a node or Selector
   * @return {Node | null} a Node instance or null if no match found.
   * @for Node
   */
  Y_Node.one = function(node) {
      var instance = null,
          cachedNode,
          uid;
  
      if (node) {
          if (typeof node == 'string') {
              node = Y_Node._fromString(node);
              if (!node) {
                  return null; // NOTE: return
              }
          } else if (node.getDOMNode) {
              return node; // NOTE: return
          }
  
          if (node.nodeType || Y.DOM.isWindow(node)) { // avoid bad input (numbers, boolean, etc)
              uid = (node.uniqueID && node.nodeType !== 9) ? node.uniqueID : node._yuid;
              instance = Y_Node._instances[uid]; // reuse exising instances
              cachedNode = instance ? instance._node : null;
              if (!instance || (cachedNode && node !== cachedNode)) { // new Node when nodes don't match
                  instance = new Y_Node(node);
                  if (node.nodeType != 11) { // dont cache document fragment
                      Y_Node._instances[instance[UID]] = instance; // cache node
                  }
              }
          }
      }
  
      return instance;
  };
  
  /**
   * The default setter for DOM properties
   * Called with instance context (this === the Node instance)
   * @method DEFAULT_SETTER
   * @static
   * @param {String} name The attribute/property being set
   * @param {any} val The value to be set
   * @return {any} The value
   */
  Y_Node.DEFAULT_SETTER = function(name, val) {
      var node = this._stateProxy,
          strPath;
  
      if (name.indexOf(DOT) > -1) {
          strPath = name;
          name = name.split(DOT);
          // only allow when defined on node
          Y.Object.setValue(node, name, val);
      } else if (typeof node[name] != 'undefined') { // pass thru DOM properties
          node[name] = val;
      }
  
      return val;
  };
  
  /**
   * The default getter for DOM properties
   * Called with instance context (this === the Node instance)
   * @method DEFAULT_GETTER
   * @static
   * @param {String} name The attribute/property to look up
   * @return {any} The current value
   */
  Y_Node.DEFAULT_GETTER = function(name) {
      var node = this._stateProxy,
          val;
  
      if (name.indexOf && name.indexOf(DOT) > -1) {
          val = Y.Object.getValue(node, name.split(DOT));
      } else if (typeof node[name] != 'undefined') { // pass thru from DOM
          val = node[name];
      }
  
      return val;
  };
  
  Y.mix(Y_Node.prototype, {
      DATA_PREFIX: 'data-',
  
      /**
       * The method called when outputting Node instances as strings
       * @method toString
       * @return {String} A string representation of the Node instance
       */
      toString: function() {
          var str = this[UID] + ': not bound to a node',
              node = this._node,
              attrs, id, className;
  
          if (node) {
              attrs = node.attributes;
              id = (attrs && attrs.id) ? node.getAttribute('id') : null;
              className = (attrs && attrs.className) ? node.getAttribute('className') : null;
              str = node[NODE_NAME];
  
              if (id) {
                  str += '#' + id;
              }
  
              if (className) {
                  str += '.' + className.replace(' ', '.');
              }
  
              // TODO: add yuid?
              str += ' ' + this[UID];
          }
          return str;
      },
  
      /**
       * Returns an attribute value on the Node instance.
       * Unless pre-configured (via `Node.ATTRS`), get hands
       * off to the underlying DOM node.  Only valid
       * attributes/properties for the node will be queried.
       * @method get
       * @param {String} attr The attribute
       * @return {any} The current value of the attribute
       */
      get: function(attr) {
          var val;
  
          if (this._getAttr) { // use Attribute imple
              val = this._getAttr(attr);
          } else {
              val = this._get(attr);
          }
  
          if (val) {
              val = Y_Node.scrubVal(val, this);
          } else if (val === null) {
              val = null; // IE: DOM null is not true null (even though they ===)
          }
          return val;
      },
  
      /**
       * Helper method for get.
       * @method _get
       * @private
       * @param {String} attr The attribute
       * @return {any} The current value of the attribute
       */
      _get: function(attr) {
          var attrConfig = Y_Node.ATTRS[attr],
              val;
  
          if (attrConfig && attrConfig.getter) {
              val = attrConfig.getter.call(this);
          } else if (Y_Node.re_aria.test(attr)) {
              val = this._node.getAttribute(attr, 2);
          } else {
              val = Y_Node.DEFAULT_GETTER.apply(this, arguments);
          }
  
          return val;
      },
  
      /**
       * Sets an attribute on the Node instance.
       * Unless pre-configured (via Node.ATTRS), set hands
       * off to the underlying DOM node.  Only valid
       * attributes/properties for the node will be set.
       * To set custom attributes use setAttribute.
       * @method set
       * @param {String} attr The attribute to be set.
       * @param {any} val The value to set the attribute to.
       * @chainable
       */
      set: function(attr, val) {
          var attrConfig = Y_Node.ATTRS[attr];
  
          if (this._setAttr) { // use Attribute imple
              this._setAttr.apply(this, arguments);
          } else { // use setters inline
              if (attrConfig && attrConfig.setter) {
                  attrConfig.setter.call(this, val, attr);
              } else if (Y_Node.re_aria.test(attr)) { // special case Aria
                  this._node.setAttribute(attr, val);
              } else {
                  Y_Node.DEFAULT_SETTER.apply(this, arguments);
              }
          }
  
          return this;
      },
  
      /**
       * Sets multiple attributes.
       * @method setAttrs
       * @param {Object} attrMap an object of name/value pairs to set
       * @chainable
       */
      setAttrs: function(attrMap) {
          if (this._setAttrs) { // use Attribute imple
              this._setAttrs(attrMap);
          } else { // use setters inline
              Y.Object.each(attrMap, function(v, n) {
                  this.set(n, v);
              }, this);
          }
  
          return this;
      },
  
      /**
       * Returns an object containing the values for the requested attributes.
       * @method getAttrs
       * @param {Array} attrs an array of attributes to get values
       * @return {Object} An object with attribute name/value pairs.
       */
      getAttrs: function(attrs) {
          var ret = {};
          if (this._getAttrs) { // use Attribute imple
              this._getAttrs(attrs);
          } else { // use setters inline
              Y.Array.each(attrs, function(v, n) {
                  ret[v] = this.get(v);
              }, this);
          }
  
          return ret;
      },
  
      /**
       * Compares nodes to determine if they match.
       * Node instances can be compared to each other and/or HTMLElements.
       * @method compareTo
       * @param {HTMLElement | Node} refNode The reference node to compare to the node.
       * @return {Boolean} True if the nodes match, false if they do not.
       */
      compareTo: function(refNode) {
          var node = this._node;
  
          if (refNode && refNode._node) {
              refNode = refNode._node;
          }
          return node === refNode;
      },
  
      /**
       * Determines whether the node is appended to the document.
       * @method inDoc
       * @param {Node|HTMLElement} doc optional An optional document to check against.
       * Defaults to current document.
       * @return {Boolean} Whether or not this node is appended to the document.
       */
      inDoc: function(doc) {
          var node = this._node;
          doc = (doc) ? doc._node || doc : node[OWNER_DOCUMENT];
          if (doc.documentElement) {
              return Y_DOM.contains(doc.documentElement, node);
          }
      },
  
      getById: function(id) {
          var node = this._node,
              ret = Y_DOM.byId(id, node[OWNER_DOCUMENT]);
          if (ret && Y_DOM.contains(node, ret)) {
              ret = Y.one(ret);
          } else {
              ret = null;
          }
          return ret;
      },
  
     /**
       * Returns the nearest ancestor that passes the test applied by supplied boolean method.
       * @method ancestor
       * @param {String | Function} fn A selector string or boolean method for testing elements.
       * If a function is used, it receives the current node being tested as the only argument.
       * @param {Boolean} testSelf optional Whether or not to include the element in the scan
       * @param {String | Function} stopFn optional A selector string or boolean
       * method to indicate when the search should stop. The search bails when the function
       * returns true or the selector matches.
       * If a function is used, it receives the current node being tested as the only argument.
       * @return {Node} The matching Node instance or null if not found
       */
      ancestor: function(fn, testSelf, stopFn) {
          // testSelf is optional, check for stopFn as 2nd arg
          if (arguments.length === 2 &&
                  (typeof testSelf == 'string' || typeof testSelf == 'function')) {
              stopFn = testSelf;
          }
  
          return Y.one(Y_DOM.ancestor(this._node, _wrapFn(fn), testSelf, _wrapFn(stopFn)));
      },
  
     /**
       * Returns the ancestors that pass the test applied by supplied boolean method.
       * @method ancestors
       * @param {String | Function} fn A selector string or boolean method for testing elements.
       * @param {Boolean} testSelf optional Whether or not to include the element in the scan
       * If a function is used, it receives the current node being tested as the only argument.
       * @return {NodeList} A NodeList instance containing the matching elements
       */
      ancestors: function(fn, testSelf, stopFn) {
          if (arguments.length === 2 &&
                  (typeof testSelf == 'string' || typeof testSelf == 'function')) {
              stopFn = testSelf;
          }
          return Y.all(Y_DOM.ancestors(this._node, _wrapFn(fn), testSelf, _wrapFn(stopFn)));
      },
  
      /**
       * Returns the previous matching sibling.
       * Returns the nearest element node sibling if no method provided.
       * @method previous
       * @param {String | Function} fn A selector or boolean method for testing elements.
       * If a function is used, it receives the current node being tested as the only argument.
       * @return {Node} Node instance or null if not found
       */
      previous: function(fn, all) {
          return Y.one(Y_DOM.elementByAxis(this._node, 'previousSibling', _wrapFn(fn), all));
      },
  
      /**
       * Returns the next matching sibling.
       * Returns the nearest element node sibling if no method provided.
       * @method next
       * @param {String | Function} fn A selector or boolean method for testing elements.
       * If a function is used, it receives the current node being tested as the only argument.
       * @return {Node} Node instance or null if not found
       */
      next: function(fn, all) {
          return Y.one(Y_DOM.elementByAxis(this._node, 'nextSibling', _wrapFn(fn), all));
      },
  
      /**
       * Returns all matching siblings.
       * Returns all siblings if no method provided.
       * @method siblings
       * @param {String | Function} fn A selector or boolean method for testing elements.
       * If a function is used, it receives the current node being tested as the only argument.
       * @return {NodeList} NodeList instance bound to found siblings
       */
      siblings: function(fn) {
          return Y.all(Y_DOM.siblings(this._node, _wrapFn(fn)));
      },
  
      /**
       * Retrieves a Node instance of nodes based on the given CSS selector.
       * @method one
       *
       * @param {string} selector The CSS selector to test against.
       * @return {Node} A Node instance for the matching HTMLElement.
       */
      one: function(selector) {
          return Y.one(Y.Selector.query(selector, this._node, true));
      },
  
      /**
       * Retrieves a NodeList based on the given CSS selector.
       * @method all
       *
       * @param {string} selector The CSS selector to test against.
       * @return {NodeList} A NodeList instance for the matching HTMLCollection/Array.
       */
      all: function(selector) {
          var nodelist = Y.all(Y.Selector.query(selector, this._node));
          nodelist._query = selector;
          nodelist._queryRoot = this._node;
          return nodelist;
      },
  
      // TODO: allow fn test
      /**
       * Test if the supplied node matches the supplied selector.
       * @method test
       *
       * @param {string} selector The CSS selector to test against.
       * @return {boolean} Whether or not the node matches the selector.
       */
      test: function(selector) {
          return Y.Selector.test(this._node, selector);
      },
  
      /**
       * Removes the node from its parent.
       * Shortcut for myNode.get('parentNode').removeChild(myNode);
       * @method remove
       * @param {Boolean} destroy whether or not to call destroy() on the node
       * after removal.
       * @chainable
       *
       */
      remove: function(destroy) {
          var node = this._node;
  
          if (node && node.parentNode) {
              node.parentNode.removeChild(node);
          }
  
          if (destroy) {
              this.destroy();
          }
  
          return this;
      },
  
      /**
       * Replace the node with the other node. This is a DOM update only
       * and does not change the node bound to the Node instance.
       * Shortcut for myNode.get('parentNode').replaceChild(newNode, myNode);
       * @method replace
       * @param {Node | HTMLNode} newNode Node to be inserted
       * @chainable
       *
       */
      replace: function(newNode) {
          var node = this._node;
          if (typeof newNode == 'string') {
              newNode = Y_Node.create(newNode);
          }
          node.parentNode.replaceChild(Y_Node.getDOMNode(newNode), node);
          return this;
      },
  
      /**
       * @method replaceChild
       * @for Node
       * @param {String | HTMLElement | Node} node Node to be inserted
       * @param {HTMLElement | Node} refNode Node to be replaced
       * @return {Node} The replaced node
       */
      replaceChild: function(node, refNode) {
          if (typeof node == 'string') {
              node = Y_DOM.create(node);
          }
  
          return Y.one(this._node.replaceChild(Y_Node.getDOMNode(node), Y_Node.getDOMNode(refNode)));
      },
  
      /**
       * Nulls internal node references, removes any plugins and event listeners
       * @method destroy
       * @param {Boolean} recursivePurge (optional) Whether or not to remove listeners from the
       * node's subtree (default is false)
       *
       */
      destroy: function(recursive) {
          var UID = Y.config.doc.uniqueID ? 'uniqueID' : '_yuid',
              instance;
  
          this.purge(); // TODO: only remove events add via this Node
  
          if (this.unplug) { // may not be a PluginHost
              this.unplug();
          }
  
          this.clearData();
  
          if (recursive) {
              Y.NodeList.each(this.all('*'), function(node) {
                  instance = Y_Node._instances[node[UID]];
                  if (instance) {
                     instance.destroy();
                  } else { // purge in case added by other means
                      Y.Event.purgeElement(node);
                  }
              });
          }
  
          this._node = null;
          this._stateProxy = null;
  
          delete Y_Node._instances[this._yuid];
      },
  
      /**
       * Invokes a method on the Node instance
       * @method invoke
       * @param {String} method The name of the method to invoke
       * @param {Any}  a, b, c, etc. Arguments to invoke the method with.
       * @return Whatever the underly method returns.
       * DOM Nodes and Collections return values
       * are converted to Node/NodeList instances.
       *
       */
      invoke: function(method, a, b, c, d, e) {
          var node = this._node,
              ret;
  
          if (a && a._node) {
              a = a._node;
          }
  
          if (b && b._node) {
              b = b._node;
          }
  
          ret = node[method](a, b, c, d, e);
          return Y_Node.scrubVal(ret, this);
      },
  
      /**
      * @method swap
      * @description Swap DOM locations with the given node.
      * This does not change which DOM node each Node instance refers to.
      * @param {Node} otherNode The node to swap with
       * @chainable
      */
      swap: Y.config.doc.documentElement.swapNode ?
          function(otherNode) {
              this._node.swapNode(Y_Node.getDOMNode(otherNode));
          } :
          function(otherNode) {
              otherNode = Y_Node.getDOMNode(otherNode);
              var node = this._node,
                  parent = otherNode.parentNode,
                  nextSibling = otherNode.nextSibling;
  
              if (nextSibling === node) {
                  parent.insertBefore(node, otherNode);
              } else if (otherNode === node.nextSibling) {
                  parent.insertBefore(otherNode, node);
              } else {
                  node.parentNode.replaceChild(otherNode, node);
                  Y_DOM.addHTML(parent, node, nextSibling);
              }
              return this;
          },
  
  
      hasMethod: function(method) {
          var node = this._node;
          return !!(node && method in node &&
                  typeof node[method] != 'unknown' &&
              (typeof node[method] == 'function' ||
                  String(node[method]).indexOf('function') === 1)); // IE reports as object, prepends space
      },
  
      isFragment: function() {
          return (this.get('nodeType') === 11);
      },
  
      /**
       * Removes and destroys all of the nodes within the node.
       * @method empty
       * @chainable
       */
      empty: function() {
          this.get('childNodes').remove().destroy(true);
          return this;
      },
  
      /**
       * Returns the DOM node bound to the Node instance
       * @method getDOMNode
       * @return {DOMNode}
       */
      getDOMNode: function() {
          return this._node;
      }
  }, true);
  
  Y.Node = Y_Node;
  Y.one = Y_Node.one;
  /**
   * The NodeList module provides support for managing collections of Nodes.
   * @module node
   * @submodule node-core
   */
  
  /**
   * The NodeList class provides a wrapper for manipulating DOM NodeLists.
   * NodeList properties can be accessed via the set/get methods.
   * Use Y.all() to retrieve NodeList instances.
   *
   * @class NodeList
   * @constructor
   * @param nodes {String|element|Node|Array} A selector, DOM element, Node, list of DOM elements, or list of Nodes with which to populate this NodeList.
   */
  
  var NodeList = function(nodes) {
      var tmp = [];
  
      if (nodes) {
          if (typeof nodes === 'string') { // selector query
              this._query = nodes;
              nodes = Y.Selector.query(nodes);
          } else if (nodes.nodeType || Y_DOM.isWindow(nodes)) { // domNode || window
              nodes = [nodes];
          } else if (nodes._node) { // Y.Node
              nodes = [nodes._node];
          } else if (nodes[0] && nodes[0]._node) { // allow array of Y.Nodes
              Y.Array.each(nodes, function(node) {
                  if (node._node) {
                      tmp.push(node._node);
                  }
              });
              nodes = tmp;
          } else { // array of domNodes or domNodeList (no mixed array of Y.Node/domNodes)
              nodes = Y.Array(nodes, 0, true);
          }
      }
  
      /**
       * The underlying array of DOM nodes bound to the Y.NodeList instance
       * @property _nodes
       * @private
       */
      this._nodes = nodes || [];
  };
  
  NodeList.NAME = 'NodeList';
  
  /**
   * Retrieves the DOM nodes bound to a NodeList instance
   * @method getDOMNodes
   * @static
   *
   * @param {NodeList} nodelist The NodeList instance
   * @return {Array} The array of DOM nodes bound to the NodeList
   */
  NodeList.getDOMNodes = function(nodelist) {
      return (nodelist && nodelist._nodes) ? nodelist._nodes : nodelist;
  };
  
  NodeList.each = function(instance, fn, context) {
      var nodes = instance._nodes;
      if (nodes && nodes.length) {
          Y.Array.each(nodes, fn, context || instance);
      } else {
      }
  };
  
  NodeList.addMethod = function(name, fn, context) {
      if (name && fn) {
          NodeList.prototype[name] = function() {
              var ret = [],
                  args = arguments;
  
              Y.Array.each(this._nodes, function(node) {
                  var UID = (node.uniqueID && node.nodeType !== 9 ) ? 'uniqueID' : '_yuid',
                      instance = Y.Node._instances[node[UID]],
                      ctx,
                      result;
  
                  if (!instance) {
                      instance = NodeList._getTempNode(node);
                  }
                  ctx = context || instance;
                  result = fn.apply(ctx, args);
                  if (result !== undefined && result !== instance) {
                      ret[ret.length] = result;
                  }
              });
  
              // TODO: remove tmp pointer
              return ret.length ? ret : this;
          };
      } else {
      }
  };
  
  NodeList.importMethod = function(host, name, altName) {
      if (typeof name === 'string') {
          altName = altName || name;
          NodeList.addMethod(name, host[name]);
      } else {
          Y.Array.each(name, function(n) {
              NodeList.importMethod(host, n);
          });
      }
  };
  
  NodeList._getTempNode = function(node) {
      var tmp = NodeList._tempNode;
      if (!tmp) {
          tmp = Y.Node.create('<div></div>');
          NodeList._tempNode = tmp;
      }
  
      tmp._node = node;
      tmp._stateProxy = node;
      return tmp;
  };
  
  Y.mix(NodeList.prototype, {
      _invoke: function(method, args, getter) {
          var ret = (getter) ? [] : this;
  
          this.each(function(node) {
              var val = node[method].apply(node, args);
              if (getter) {
                  ret.push(val);
              }
          });
  
          return ret;
      },
  
      /**
       * Retrieves the Node instance at the given index.
       * @method item
       *
       * @param {Number} index The index of the target Node.
       * @return {Node} The Node instance at the given index.
       */
      item: function(index) {
          return Y.one((this._nodes || [])[index]);
      },
  
      /**
       * Applies the given function to each Node in the NodeList.
       * @method each
       * @param {Function} fn The function to apply. It receives 3 arguments:
       * the current node instance, the node's index, and the NodeList instance
       * @param {Object} context optional An optional context to apply the function with
       * Default context is the current Node instance
       * @chainable
       */
      each: function(fn, context) {
          var instance = this;
          Y.Array.each(this._nodes, function(node, index) {
              node = Y.one(node);
              return fn.call(context || node, node, index, instance);
          });
          return instance;
      },
  
      batch: function(fn, context) {
          var nodelist = this;
  
          Y.Array.each(this._nodes, function(node, index) {
              var instance = Y.Node._instances[node[UID]];
              if (!instance) {
                  instance = NodeList._getTempNode(node);
              }
  
              return fn.call(context || instance, instance, index, nodelist);
          });
          return nodelist;
      },
  
      /**
       * Executes the function once for each node until a true value is returned.
       * @method some
       * @param {Function} fn The function to apply. It receives 3 arguments:
       * the current node instance, the node's index, and the NodeList instance
       * @param {Object} context optional An optional context to execute the function from.
       * Default context is the current Node instance
       * @return {Boolean} Whether or not the function returned true for any node.
       */
      some: function(fn, context) {
          var instance = this;
          return Y.Array.some(this._nodes, function(node, index) {
              node = Y.one(node);
              context = context || node;
              return fn.call(context, node, index, instance);
          });
      },
  
      /**
       * Creates a documenFragment from the nodes bound to the NodeList instance
       * @method toFrag
       * @return {Node} a Node instance bound to the documentFragment
       */
      toFrag: function() {
          return Y.one(Y.DOM._nl2frag(this._nodes));
      },
  
      /**
       * Returns the index of the node in the NodeList instance
       * or -1 if the node isn't found.
       * @method indexOf
       * @param {Node | DOMNode} node the node to search for
       * @return {Int} the index of the node value or -1 if not found
       */
      indexOf: function(node) {
          return Y.Array.indexOf(this._nodes, Y.Node.getDOMNode(node));
      },
  
      /**
       * Filters the NodeList instance down to only nodes matching the given selector.
       * @method filter
       * @param {String} selector The selector to filter against
       * @return {NodeList} NodeList containing the updated collection
       * @see Selector
       */
      filter: function(selector) {
          return Y.all(Y.Selector.filter(this._nodes, selector));
      },
  
  
      /**
       * Creates a new NodeList containing all nodes at every n indices, where
       * remainder n % index equals r.
       * (zero-based index).
       * @method modulus
       * @param {Int} n The offset to use (return every nth node)
       * @param {Int} r An optional remainder to use with the modulus operation (defaults to zero)
       * @return {NodeList} NodeList containing the updated collection
       */
      modulus: function(n, r) {
          r = r || 0;
          var nodes = [];
          NodeList.each(this, function(node, i) {
              if (i % n === r) {
                  nodes.push(node);
              }
          });
  
          return Y.all(nodes);
      },
  
      /**
       * Creates a new NodeList containing all nodes at odd indices
       * (zero-based index).
       * @method odd
       * @return {NodeList} NodeList containing the updated collection
       */
      odd: function() {
          return this.modulus(2, 1);
      },
  
      /**
       * Creates a new NodeList containing all nodes at even indices
       * (zero-based index), including zero.
       * @method even
       * @return {NodeList} NodeList containing the updated collection
       */
      even: function() {
          return this.modulus(2);
      },
  
      destructor: function() {
      },
  
      /**
       * Reruns the initial query, when created using a selector query
       * @method refresh
       * @chainable
       */
      refresh: function() {
          var doc,
              nodes = this._nodes,
              query = this._query,
              root = this._queryRoot;
  
          if (query) {
              if (!root) {
                  if (nodes && nodes[0] && nodes[0].ownerDocument) {
                      root = nodes[0].ownerDocument;
                  }
              }
  
              this._nodes = Y.Selector.query(query, root);
          }
  
          return this;
      },
  
      /**
       * Returns the current number of items in the NodeList.
       * @method size
       * @return {Int} The number of items in the NodeList.
       */
      size: function() {
          return this._nodes.length;
      },
  
      /**
       * Determines if the instance is bound to any nodes
       * @method isEmpty
       * @return {Boolean} Whether or not the NodeList is bound to any nodes
       */
      isEmpty: function() {
          return this._nodes.length < 1;
      },
  
      toString: function() {
          var str = '',
              errorMsg = this[UID] + ': not bound to any nodes',
              nodes = this._nodes,
              node;
  
          if (nodes && nodes[0]) {
              node = nodes[0];
              str += node[NODE_NAME];
              if (node.id) {
                  str += '#' + node.id;
              }
  
              if (node.className) {
                  str += '.' + node.className.replace(' ', '.');
              }
  
              if (nodes.length > 1) {
                  str += '...[' + nodes.length + ' items]';
              }
          }
          return str || errorMsg;
      },
  
      /**
       * Returns the DOM node bound to the Node instance
       * @method getDOMNodes
       * @return {Array}
       */
      getDOMNodes: function() {
          return this._nodes;
      }
  }, true);
  
  NodeList.importMethod(Y.Node.prototype, [
       /** 
        * Called on each Node instance. Nulls internal node references, 
        * removes any plugins and event listeners
        * @method destroy
        * @param {Boolean} recursivePurge (optional) Whether or not to 
        * remove listeners from the node's subtree (default is false)
        * @see Node.destroy
        */
      'destroy',
  
       /** 
        * Called on each Node instance. Removes and destroys all of the nodes 
        * within the node
        * @method empty
        * @chainable
        * @see Node.empty
        */
      'empty',
  
       /** 
        * Called on each Node instance. Removes the node from its parent.
        * Shortcut for myNode.get('parentNode').removeChild(myNode);
        * @method remove
        * @param {Boolean} destroy whether or not to call destroy() on the node
        * after removal.
        * @chainable
        * @see Node.remove
        */
      'remove',
  
       /** 
        * Called on each Node instance. Sets an attribute on the Node instance.
        * Unless pre-configured (via Node.ATTRS), set hands
        * off to the underlying DOM node.  Only valid
        * attributes/properties for the node will be set.
        * To set custom attributes use setAttribute.
        * @method set
        * @param {String} attr The attribute to be set.
        * @param {any} val The value to set the attribute to.
        * @chainable
        * @see Node.set
        */
      'set'
  ]);
  
  // one-off implementation to convert array of Nodes to NodeList
  // e.g. Y.all('input').get('parentNode');
  
  /** Called on each Node instance
    * @method get
    * @see Node
    */
  NodeList.prototype.get = function(attr) {
      var ret = [],
          nodes = this._nodes,
          isNodeList = false,
          getTemp = NodeList._getTempNode,
          instance,
          val;
  
      if (nodes[0]) {
          instance = Y.Node._instances[nodes[0]._yuid] || getTemp(nodes[0]);
          val = instance._get(attr);
          if (val && val.nodeType) {
              isNodeList = true;
          }
      }
  
      Y.Array.each(nodes, function(node) {
          instance = Y.Node._instances[node._yuid];
  
          if (!instance) {
              instance = getTemp(node);
          }
  
          val = instance._get(attr);
          if (!isNodeList) { // convert array of Nodes to NodeList
              val = Y.Node.scrubVal(val, instance);
          }
  
          ret.push(val);
      });
  
      return (isNodeList) ? Y.all(ret) : ret;
  };
  
  Y.NodeList = NodeList;
  
  Y.all = function(nodes) {
      return new NodeList(nodes);
  };
  
  Y.Node.all = Y.all;
  /**
   * @module node
   * @submodule node-core
   */
  
  var Y_NodeList = Y.NodeList,
      ArrayProto = Array.prototype,
      ArrayMethods = {
          /** Returns a new NodeList combining the given NodeList(s)
            * @for NodeList
            * @method concat
            * @param {NodeList | Array} valueN Arrays/NodeLists and/or values to
            * concatenate to the resulting NodeList
            * @return {NodeList} A new NodeList comprised of this NodeList joined with the input.
            */
          'concat': 1,
          /** Removes the last from the NodeList and returns it.
            * @for NodeList
            * @method pop
            * @return {Node} The last item in the NodeList.
            */
          'pop': 0,
          /** Adds the given Node(s) to the end of the NodeList.
            * @for NodeList
            * @method push
            * @param {Node | DOMNode} nodes One or more nodes to add to the end of the NodeList.
            */
          'push': 0,
          /** Removes the first item from the NodeList and returns it.
            * @for NodeList
            * @method shift
            * @return {Node} The first item in the NodeList.
            */
          'shift': 0,
          /** Returns a new NodeList comprising the Nodes in the given range.
            * @for NodeList
            * @method slice
            * @param {Number} begin Zero-based index at which to begin extraction.
            As a negative index, start indicates an offset from the end of the sequence. slice(-2) extracts the second-to-last element and the last element in the sequence.
            * @param {Number} end Zero-based index at which to end extraction. slice extracts up to but not including end.
            slice(1,4) extracts the second element through the fourth element (elements indexed 1, 2, and 3).
            As a negative index, end indicates an offset from the end of the sequence. slice(2,-1) extracts the third element through the second-to-last element in the sequence.
            If end is omitted, slice extracts to the end of the sequence.
            * @return {NodeList} A new NodeList comprised of this NodeList joined with the input.
            */
          'slice': 1,
          /** Changes the content of the NodeList, adding new elements while removing old elements.
            * @for NodeList
            * @method splice
            * @param {Number} index Index at which to start changing the array. If negative, will begin that many elements from the end.
            * @param {Number} howMany An integer indicating the number of old array elements to remove. If howMany is 0, no elements are removed. In this case, you should specify at least one new element. If no howMany parameter is specified (second syntax above, which is a SpiderMonkey extension), all elements after index are removed.
            * {Node | DOMNode| element1, ..., elementN
            The elements to add to the array. If you don't specify any elements, splice simply removes elements from the array.
            * @return {NodeList} The element(s) removed.
            */
          'splice': 1,
          /** Adds the given Node(s) to the beginning of the NodeList.
            * @for NodeList
            * @method unshift
            * @param {Node | DOMNode} nodes One or more nodes to add to the NodeList.
            */
          'unshift': 0
      };
  
  
  Y.Object.each(ArrayMethods, function(returnNodeList, name) {
      Y_NodeList.prototype[name] = function() {
          var args = [],
              i = 0,
              arg,
              ret;
  
          while (typeof (arg = arguments[i++]) != 'undefined') { // use DOM nodes/nodeLists
              args.push(arg._node || arg._nodes || arg);
          }
  
          ret = ArrayProto[name].apply(this._nodes, args);
  
          if (returnNodeList) {
              ret = Y.all(ret);
          } else {
              ret = Y.Node.scrubVal(ret);
          }
  
          return ret;
      };
  });
  /**
   * @module node
   * @submodule node-core
   */
  
  Y.Array.each([
      /**
       * Passes through to DOM method.
       * @for Node
       * @method removeChild
       * @param {HTMLElement | Node} node Node to be removed
       * @return {Node} The removed node
       */
      'removeChild',
  
      /**
       * Passes through to DOM method.
       * @method hasChildNodes
       * @return {Boolean} Whether or not the node has any childNodes
       */
      'hasChildNodes',
  
      /**
       * Passes through to DOM method.
       * @method cloneNode
       * @param {Boolean} deep Whether or not to perform a deep clone, which includes
       * subtree and attributes
       * @return {Node} The clone
       */
      'cloneNode',
  
      /**
       * Passes through to DOM method.
       * @method hasAttribute
       * @param {String} attribute The attribute to test for
       * @return {Boolean} Whether or not the attribute is present
       */
      'hasAttribute',
  
      /**
       * Passes through to DOM method.
       * @method scrollIntoView
       * @chainable
       */
      'scrollIntoView',
  
      /**
       * Passes through to DOM method.
       * @method getElementsByTagName
       * @param {String} tagName The tagName to collect
       * @return {NodeList} A NodeList representing the HTMLCollection
       */
      'getElementsByTagName',
  
      /**
       * Passes through to DOM method.
       * @method focus
       * @chainable
       */
      'focus',
  
      /**
       * Passes through to DOM method.
       * @method blur
       * @chainable
       */
      'blur',
  
      /**
       * Passes through to DOM method.
       * Only valid on FORM elements
       * @method submit
       * @chainable
       */
      'submit',
  
      /**
       * Passes through to DOM method.
       * Only valid on FORM elements
       * @method reset
       * @chainable
       */
      'reset',
  
      /**
       * Passes through to DOM method.
       * @method select
       * @chainable
       */
       'select',
  
      /**
       * Passes through to DOM method.
       * Only valid on TABLE elements
       * @method createCaption
       * @chainable
       */
      'createCaption'
  
  ], function(method) {
      Y.Node.prototype[method] = function(arg1, arg2, arg3) {
          var ret = this.invoke(method, arg1, arg2, arg3);
          return ret;
      };
  });
  
  /**
   * Passes through to DOM method.
   * @method removeAttribute
   * @param {String} attribute The attribute to be removed
   * @chainable
   */
   // one-off implementation due to IE returning boolean, breaking chaining
  Y.Node.prototype.removeAttribute = function(attr) {
      var node = this._node;
      if (node) {
          node.removeAttribute(attr, 0); // comma zero for IE < 8 to force case-insensitive
      }
  
      return this;
  };
  
  Y.Node.importMethod(Y.DOM, [
      /**
       * Determines whether the node is an ancestor of another HTML element in the DOM hierarchy.
       * @method contains
       * @param {Node | HTMLElement} needle The possible node or descendent
       * @return {Boolean} Whether or not this node is the needle its ancestor
       */
      'contains',
      /**
       * Allows setting attributes on DOM nodes, normalizing in some cases.
       * This passes through to the DOM node, allowing for custom attributes.
       * @method setAttribute
       * @for Node
       * @chainable
       * @param {string} name The attribute name
       * @param {string} value The value to set
       */
      'setAttribute',
      /**
       * Allows getting attributes on DOM nodes, normalizing in some cases.
       * This passes through to the DOM node, allowing for custom attributes.
       * @method getAttribute
       * @for Node
       * @param {string} name The attribute name
       * @return {string} The attribute value
       */
      'getAttribute',
  
      /**
       * Wraps the given HTML around the node.
       * @method wrap
       * @param {String} html The markup to wrap around the node.
       * @chainable
       * @for Node
       */
      'wrap',
  
      /**
       * Removes the node's parent node.
       * @method unwrap
       * @chainable
       */
      'unwrap',
  
      /**
       * Applies a unique ID to the node if none exists
       * @method generateID
       * @return {String} The existing or generated ID
       */
      'generateID'
  ]);
  
  Y.NodeList.importMethod(Y.Node.prototype, [
  /**
   * Allows getting attributes on DOM nodes, normalizing in some cases.
   * This passes through to the DOM node, allowing for custom attributes.
   * @method getAttribute
   * @see Node
   * @for NodeList
   * @param {string} name The attribute name
   * @return {string} The attribute value
   */
  
      'getAttribute',
  /**
   * Allows setting attributes on DOM nodes, normalizing in some cases.
   * This passes through to the DOM node, allowing for custom attributes.
   * @method setAttribute
   * @see Node
   * @for NodeList
   * @chainable
   * @param {string} name The attribute name
   * @param {string} value The value to set
   */
      'setAttribute',
  
  /**
   * Allows for removing attributes on DOM nodes.
   * This passes through to the DOM node, allowing for custom attributes.
   * @method removeAttribute
   * @see Node
   * @for NodeList
   * @param {string} name The attribute to remove
   */
      'removeAttribute',
  /**
   * Removes the parent node from node in the list.
   * @method unwrap
   * @chainable
   */
      'unwrap',
  /**
   * Wraps the given HTML around each node.
   * @method wrap
   * @param {String} html The markup to wrap around the node.
   * @chainable
   */
      'wrap',
  
  /**
   * Applies a unique ID to each node if none exists
   * @method generateID
   * @return {String} The existing or generated ID
   */
      'generateID'
  ]);
  
  
  }, '@VERSION@' ,{requires:['dom-core', 'selector']});
  YUI.add('node-base', function(Y) {
  
  /**
   * @module node
   * @submodule node-base
   */
  
  var methods = [
  /**
   * Determines whether each node has the given className.
   * @method hasClass
   * @for Node
   * @param {String} className the class name to search for
   * @return {Boolean} Whether or not the element has the specified class
   */
   'hasClass',
  
  /**
   * Adds a class name to each node.
   * @method addClass
   * @param {String} className the class name to add to the node's class attribute
   * @chainable
   */
   'addClass',
  
  /**
   * Removes a class name from each node.
   * @method removeClass
   * @param {String} className the class name to remove from the node's class attribute
   * @chainable
   */
   'removeClass',
  
  /**
   * Replace a class with another class for each node.
   * If no oldClassName is present, the newClassName is simply added.
   * @method replaceClass
   * @param {String} oldClassName the class name to be replaced
   * @param {String} newClassName the class name that will be replacing the old class name
   * @chainable
   */
   'replaceClass',
  
  /**
   * If the className exists on the node it is removed, if it doesn't exist it is added.
   * @method toggleClass
   * @param {String} className the class name to be toggled
   * @param {Boolean} force Option to force adding or removing the class.
   * @chainable
   */
   'toggleClass'
  ];
  
  Y.Node.importMethod(Y.DOM, methods);
  /**
   * Determines whether each node has the given className.
   * @method hasClass
   * @see Node.hasClass
   * @for NodeList
   * @param {String} className the class name to search for
   * @return {Array} An array of booleans for each node bound to the NodeList.
   */
  
  /**
   * Adds a class name to each node.
   * @method addClass
   * @see Node.addClass
   * @param {String} className the class name to add to the node's class attribute
   * @chainable
   */
  
  /**
   * Removes a class name from each node.
   * @method removeClass
   * @see Node.removeClass
   * @param {String} className the class name to remove from the node's class attribute
   * @chainable
   */
  
  /**
   * Replace a class with another class for each node.
   * If no oldClassName is present, the newClassName is simply added.
   * @method replaceClass
   * @see Node.replaceClass
   * @param {String} oldClassName the class name to be replaced
   * @param {String} newClassName the class name that will be replacing the old class name
   * @chainable
   */
  
  /**
   * If the className exists on the node it is removed, if it doesn't exist it is added.
   * @method toggleClass
   * @see Node.toggleClass
   * @param {String} className the class name to be toggled
   * @chainable
   */
  Y.NodeList.importMethod(Y.Node.prototype, methods);
  /**
   * @module node
   * @submodule node-base
   */
  
  var Y_Node = Y.Node,
      Y_DOM = Y.DOM;
  
  /**
   * Returns a new dom node using the provided markup string.
   * @method create
   * @static
   * @param {String} html The markup used to create the element
   * Use <a href="../classes/Escape.html#method_html">`Y.Escape.html()`</a>
   * to escape html content.
   * @param {HTMLDocument} doc An optional document context
   * @return {Node} A Node instance bound to a DOM node or fragment
   * @for Node
   */
  Y_Node.create = function(html, doc) {
      if (doc && doc._node) {
          doc = doc._node;
      }
      return Y.one(Y_DOM.create(html, doc));
  };
  
  Y.mix(Y_Node.prototype, {
      /**
       * Creates a new Node using the provided markup string.
       * @method create
       * @param {String} html The markup used to create the element.
       * Use <a href="../classes/Escape.html#method_html">`Y.Escape.html()`</a>
       * to escape html content.
       * @param {HTMLDocument} doc An optional document context
       * @return {Node} A Node instance bound to a DOM node or fragment
       */
      create: Y_Node.create,
  
      /**
       * Inserts the content before the reference node.
       * @method insert
       * @param {String | Node | HTMLElement | NodeList | HTMLCollection} content The content to insert
       * Use <a href="../classes/Escape.html#method_html">`Y.Escape.html()`</a>
       * to escape html content.
       * @param {Int | Node | HTMLElement | String} where The position to insert at.
       * Possible "where" arguments
       * <dl>
       * <dt>Y.Node</dt>
       * <dd>The Node to insert before</dd>
       * <dt>HTMLElement</dt>
       * <dd>The element to insert before</dd>
       * <dt>Int</dt>
       * <dd>The index of the child element to insert before</dd>
       * <dt>"replace"</dt>
       * <dd>Replaces the existing HTML</dd>
       * <dt>"before"</dt>
       * <dd>Inserts before the existing HTML</dd>
       * <dt>"before"</dt>
       * <dd>Inserts content before the node</dd>
       * <dt>"after"</dt>
       * <dd>Inserts content after the node</dd>
       * </dl>
       * @chainable
       */
      insert: function(content, where) {
          this._insert(content, where);
          return this;
      },
  
      _insert: function(content, where) {
          var node = this._node,
              ret = null;
  
          if (typeof where == 'number') { // allow index
              where = this._node.childNodes[where];
          } else if (where && where._node) { // Node
              where = where._node;
          }
  
          if (content && typeof content != 'string') { // allow Node or NodeList/Array instances
              content = content._node || content._nodes || content;
          }
          ret = Y_DOM.addHTML(node, content, where);
  
          return ret;
      },
  
      /**
       * Inserts the content as the firstChild of the node.
       * @method prepend
       * @param {String | Node | HTMLElement} content The content to insert
       * Use <a href="../classes/Escape.html#method_html">`Y.Escape.html()`</a>
       * to escape html content.
       * @chainable
       */
      prepend: function(content) {
          return this.insert(content, 0);
      },
  
      /**
       * Inserts the content as the lastChild of the node.
       * @method append
       * @param {String | Node | HTMLElement} content The content to insert
       * Use <a href="../classes/Escape.html#method_html">`Y.Escape.html()`</a>
       * to escape html content.
       * @chainable
       */
      append: function(content) {
          return this.insert(content, null);
      },
  
      /**
       * @method appendChild
       * @param {String | HTMLElement | Node} node Node to be appended
       * Use <a href="../classes/Escape.html#method_html">`Y.Escape.html()`</a>
       * to escape html content.
       * @return {Node} The appended node
       */
      appendChild: function(node) {
          return Y_Node.scrubVal(this._insert(node));
      },
  
      /**
       * @method insertBefore
       * @param {String | HTMLElement | Node} newNode Node to be appended
       * @param {HTMLElement | Node} refNode Node to be inserted before
       * Use <a href="../classes/Escape.html#method_html">`Y.Escape.html()`</a>
       * to escape html content.
       * @return {Node} The inserted node
       */
      insertBefore: function(newNode, refNode) {
          return Y.Node.scrubVal(this._insert(newNode, refNode));
      },
  
      /**
       * Appends the node to the given node.
       * @method appendTo
       * @param {Node | HTMLElement} node The node to append to
       * @chainable
       */
      appendTo: function(node) {
          Y.one(node).append(this);
          return this;
      },
  
      /**
       * Replaces the node's current content with the content.
       * Note that this passes to innerHTML and is not escaped.
       * Use <a href="../classes/Escape.html#method_html">`Y.Escape.html()`</a>
       * to escape html content or `set('text')` to add as text.
       * @method setContent
       * @deprecated Use setHTML
       * @param {String | Node | HTMLElement | NodeList | HTMLCollection} content The content to insert
       * @chainable
       */
      setContent: function(content) {
          this._insert(content, 'replace');
          return this;
      },
  
      /**
       * Returns the node's current content (e.g. innerHTML)
       * @method getContent
       * @deprecated Use getHTML
       * @return {String} The current content
       */
      getContent: function(content) {
          return this.get('innerHTML');
      }
  });
  
  /**
   * Replaces the node's current html content with the content provided.
   * Note that this passes to innerHTML and is not escaped.
   * Use `Y.Escape.html()` to escape HTML, or `set('text')` to add as text.
   * @method setHTML
   * @param {String | HTML | Node | HTMLElement | NodeList | HTMLCollection} content The content to insert
   * @chainable
   */
  Y.Node.prototype.setHTML = Y.Node.prototype.setContent;
  
  /**
   * Returns the node's current html content (e.g. innerHTML)
   * @method getHTML
   * @return {String} The html content
   */
  Y.Node.prototype.getHTML = Y.Node.prototype.getContent;
  
  Y.NodeList.importMethod(Y.Node.prototype, [
      /**
       * Called on each Node instance
       * @for NodeList
       * @method append
       * @see Node.append
       */
      'append',
  
      /**
       * Called on each Node instance
       * @for NodeList
       * @method insert
       * @see Node.insert
       */
      'insert',
  
      /**
       * Called on each Node instance
       * @for NodeList
       * @method appendChild
       * @see Node.appendChild
       */
      'appendChild',
  
      /**
       * Called on each Node instance
       * @for NodeList
       * @method insertBefore
       * @see Node.insertBefore
       */
      'insertBefore',
  
      /**
       * Called on each Node instance
       * @for NodeList
       * @method prepend
       * @see Node.prepend
       */
      'prepend',
  
      /**
       * Called on each Node instance
       * Note that this passes to innerHTML and is not escaped.
       * Use `Y.Escape.html()` to escape HTML, or `set('text')` to add as text.
       * @for NodeList
       * @method setContent
       * @deprecated Use setHTML
       */
      'setContent',
  
      /**
       * Called on each Node instance
       * @for NodeList
       * @method getContent
       * @deprecated Use getHTML
       */
      'getContent',
  
      /**
       * Called on each Node instance
       * Note that this passes to innerHTML and is not escaped.
       * Use `Y.Escape.html()` to escape HTML, or `set('text')` to add as text.
       * @for NodeList
       * @method setHTML
       * @see Node.setHTML
       */
      'setHTML',
  
      /**
       * Called on each Node instance
       * @for NodeList
       * @method getHTML
       * @see Node.getHTML
       */
      'getHTML'
  ]);
  /**
   * @module node
   * @submodule node-base
   */
  
  var Y_Node = Y.Node,
      Y_DOM = Y.DOM;
  
  /**
   * Static collection of configuration attributes for special handling
   * @property ATTRS
   * @static
   * @type object
   */
  Y_Node.ATTRS = {
      /**
       * Allows for getting and setting the text of an element.
       * Formatting is preserved and special characters are treated literally.
       * @config text
       * @type String
       */
      text: {
          getter: function() {
              return Y_DOM.getText(this._node);
          },
  
          setter: function(content) {
              Y_DOM.setText(this._node, content);
              return content;
          }
      },
  
      /**
       * Allows for getting and setting the text of an element.
       * Formatting is preserved and special characters are treated literally.
       * @config for
       * @type String
       */
      'for': {
          getter: function() {
              return Y_DOM.getAttribute(this._node, 'for');
          },
  
          setter: function(val) {
              Y_DOM.setAttribute(this._node, 'for', val);
              return val;
          }
      },
  
      'options': {
          getter: function() {
              return this._node.getElementsByTagName('option');
          }
      },
  
      /**
       * Returns a NodeList instance of all HTMLElement children.
       * @readOnly
       * @config children
       * @type NodeList
       */
      'children': {
          getter: function() {
              var node = this._node,
                  children = node.children,
                  childNodes, i, len;
  
              if (!children) {
                  childNodes = node.childNodes;
                  children = [];
  
                  for (i = 0, len = childNodes.length; i < len; ++i) {
                      if (childNodes[i].tagName) {
                          children[children.length] = childNodes[i];
                      }
                  }
              }
              return Y.all(children);
          }
      },
  
      value: {
          getter: function() {
              return Y_DOM.getValue(this._node);
          },
  
          setter: function(val) {
              Y_DOM.setValue(this._node, val);
              return val;
          }
      }
  };
  
  Y.Node.importMethod(Y.DOM, [
      /**
       * Allows setting attributes on DOM nodes, normalizing in some cases.
       * This passes through to the DOM node, allowing for custom attributes.
       * @method setAttribute
       * @for Node
       * @for NodeList
       * @chainable
       * @param {string} name The attribute name
       * @param {string} value The value to set
       */
      'setAttribute',
      /**
       * Allows getting attributes on DOM nodes, normalizing in some cases.
       * This passes through to the DOM node, allowing for custom attributes.
       * @method getAttribute
       * @for Node
       * @for NodeList
       * @param {string} name The attribute name
       * @return {string} The attribute value
       */
      'getAttribute'
  
  ]);
  /**
   * @module node
   * @submodule node-base
   */
  
  var Y_Node = Y.Node;
  var Y_NodeList = Y.NodeList;
  /**
   * List of events that route to DOM events
   * @static
   * @property DOM_EVENTS
   * @for Node
   */
  
  Y_Node.DOM_EVENTS = {
      abort: 1,
      beforeunload: 1,
      blur: 1,
      change: 1,
      click: 1,
      close: 1,
      command: 1,
      contextmenu: 1,
      dblclick: 1,
      DOMMouseScroll: 1,
      drag: 1,
      dragstart: 1,
      dragenter: 1,
      dragover: 1,
      dragleave: 1,
      dragend: 1,
      drop: 1,
      error: 1,
      focus: 1,
      key: 1,
      keydown: 1,
      keypress: 1,
      keyup: 1,
      load: 1,
      message: 1,
      mousedown: 1,
      mouseenter: 1,
      mouseleave: 1,
      mousemove: 1,
      mousemultiwheel: 1,
      mouseout: 1,
      mouseover: 1,
      mouseup: 1,
      mousewheel: 1,
      orientationchange: 1,
      reset: 1,
      resize: 1,
      select: 1,
      selectstart: 1,
      submit: 1,
      scroll: 1,
      textInput: 1,
      unload: 1
  };
  
  // Add custom event adaptors to this list.  This will make it so
  // that delegate, key, available, contentready, etc all will
  // be available through Node.on
  Y.mix(Y_Node.DOM_EVENTS, Y.Env.evt.plugins);
  
  Y.augment(Y_Node, Y.EventTarget);
  
  Y.mix(Y_Node.prototype, {
      /**
       * Removes event listeners from the node and (optionally) its subtree
       * @method purge
       * @param {Boolean} recurse (optional) Whether or not to remove listeners from the
       * node's subtree
       * @param {String} type (optional) Only remove listeners of the specified type
       * @chainable
       *
       */
      purge: function(recurse, type) {
          Y.Event.purgeElement(this._node, recurse, type);
          return this;
      }
  
  });
  
  Y.mix(Y.NodeList.prototype, {
      _prepEvtArgs: function(type, fn, context) {
          // map to Y.on/after signature (type, fn, nodes, context, arg1, arg2, etc)
          var args = Y.Array(arguments, 0, true);
  
          if (args.length < 2) { // type only (event hash) just add nodes
              args[2] = this._nodes;
          } else {
              args.splice(2, 0, this._nodes);
          }
  
          args[3] = context || this; // default to NodeList instance as context
  
          return args;
      },
  
      /**
      Subscribe a callback function for each `Node` in the collection to execute
      in response to a DOM event.
  
      NOTE: Generally, the `on()` method should be avoided on `NodeLists`, in
      favor of using event delegation from a parent Node.  See the Event user
      guide for details.
  
      Most DOM events are associated with a preventable default behavior, such as
      link clicks navigating to a new page.  Callbacks are passed a
      `DOMEventFacade` object as their first argument (usually called `e`) that
      can be used to prevent this default behavior with `e.preventDefault()`. See
      the `DOMEventFacade` API for all available properties and methods on the
      object.
  
      By default, the `this` object will be the `NodeList` that the subscription
      came from, <em>not the `Node` that received the event</em>.  Use
      `e.currentTarget` to refer to the `Node`.
  
      Returning `false` from a callback is supported as an alternative to calling
      `e.preventDefault(); e.stopPropagation();`.  However, it is recommended to
      use the event methods.
  
      @example
  
          Y.all(".sku").on("keydown", function (e) {
              if (e.keyCode === 13) {
                  e.preventDefault();
  
                  // Use e.currentTarget to refer to the individual Node
                  var item = Y.MyApp.searchInventory( e.currentTarget.get('value') );
                  // etc ...
              }
          });
  
      @method on
      @param {String} type The name of the event
      @param {Function} fn The callback to execute in response to the event
      @param {Object} [context] Override `this` object in callback
      @param {Any} [arg*] 0..n additional arguments to supply to the subscriber
      @return {EventHandle} A subscription handle capable of detaching that
                            subscription
      @for NodeList
      **/
      on: function(type, fn, context) {
          return Y.on.apply(Y, this._prepEvtArgs.apply(this, arguments));
      },
  
      /**
       * Applies an one-time event listener to each Node bound to the NodeList.
       * @method once
       * @param {String} type The event being listened for
       * @param {Function} fn The handler to call when the event fires
       * @param {Object} context The context to call the handler with.
       * Default is the NodeList instance.
       * @return {EventHandle} A subscription handle capable of detaching that
       *                    subscription
       * @for NodeList
       */
      once: function(type, fn, context) {
          return Y.once.apply(Y, this._prepEvtArgs.apply(this, arguments));
      },
  
      /**
       * Applies an event listener to each Node bound to the NodeList.
       * The handler is called only after all on() handlers are called
       * and the event is not prevented.
       * @method after
       * @param {String} type The event being listened for
       * @param {Function} fn The handler to call when the event fires
       * @param {Object} context The context to call the handler with.
       * Default is the NodeList instance.
       * @return {EventHandle} A subscription handle capable of detaching that
       *                    subscription
       * @for NodeList
       */
      after: function(type, fn, context) {
          return Y.after.apply(Y, this._prepEvtArgs.apply(this, arguments));
      },
  
      /**
       * Applies an one-time event listener to each Node bound to the NodeList
       * that will be called only after all on() handlers are called and the
       * event is not prevented.
       *
       * @method onceAfter
       * @param {String} type The event being listened for
       * @param {Function} fn The handler to call when the event fires
       * @param {Object} context The context to call the handler with.
       * Default is the NodeList instance.
       * @return {EventHandle} A subscription handle capable of detaching that
       *                    subscription
       * @for NodeList
       */
      onceAfter: function(type, fn, context) {
          return Y.onceAfter.apply(Y, this._prepEvtArgs.apply(this, arguments));
      }
  });
  
  Y_NodeList.importMethod(Y.Node.prototype, [
      /**
        * Called on each Node instance
        * @method detach
        * @see Node.detach
        * @for NodeList
        */
      'detach',
  
      /** Called on each Node instance
        * @method detachAll
        * @see Node.detachAll
        * @for NodeList
        */
      'detachAll'
  ]);
  
  /**
  Subscribe a callback function to execute in response to a DOM event or custom
  event.
  
  Most DOM events are associated with a preventable default behavior such as
  link clicks navigating to a new page.  Callbacks are passed a `DOMEventFacade`
  object as their first argument (usually called `e`) that can be used to
  prevent this default behavior with `e.preventDefault()`. See the
  `DOMEventFacade` API for all available properties and methods on the object.
  
  If the event name passed as the first parameter is not a whitelisted DOM event,
  it will be treated as a custom event subscriptions, allowing
  `node.fire('customEventName')` later in the code.  Refer to the Event user guide
  for the full DOM event whitelist.
  
  By default, the `this` object in the callback will refer to the subscribed
  `Node`.
  
  Returning `false` from a callback is supported as an alternative to calling
  `e.preventDefault(); e.stopPropagation();`.  However, it is recommended to use
  the event methods.
  
  @example
  
      Y.one("#my-form").on("submit", function (e) {
          e.preventDefault();
  
          // proceed with ajax form submission instead...
      });
  
  @method on
  @param {String} type The name of the event
  @param {Function} fn The callback to execute in response to the event
  @param {Object} [context] Override `this` object in callback
  @param {Any} [arg*] 0..n additional arguments to supply to the subscriber
  @return {EventHandle} A subscription handle capable of detaching that
                        subscription
  @for Node
  **/
  
  Y.mix(Y.Node.ATTRS, {
      offsetHeight: {
          setter: function(h) {
              Y.DOM.setHeight(this._node, h);
              return h;
          },
  
          getter: function() {
              return this._node.offsetHeight;
          }
      },
  
      offsetWidth: {
          setter: function(w) {
              Y.DOM.setWidth(this._node, w);
              return w;
          },
  
          getter: function() {
              return this._node.offsetWidth;
          }
      }
  });
  
  Y.mix(Y.Node.prototype, {
      sizeTo: function(w, h) {
          var node;
          if (arguments.length < 2) {
              node = Y.one(w);
              w = node.get('offsetWidth');
              h = node.get('offsetHeight');
          }
  
          this.setAttrs({
              offsetWidth: w,
              offsetHeight: h
          });
      }
  });
  /**
   * @module node
   * @submodule node-base
   */
  
  var Y_Node = Y.Node;
  
  Y.mix(Y_Node.prototype, {
      /**
       * Makes the node visible.
       * If the "transition" module is loaded, show optionally
       * animates the showing of the node using either the default
       * transition effect ('fadeIn'), or the given named effect.
       * @method show
       * @for Node
       * @param {String} name A named Transition effect to use as the show effect.
       * @param {Object} config Options to use with the transition.
       * @param {Function} callback An optional function to run after the transition completes.
       * @chainable
       */
      show: function(callback) {
          callback = arguments[arguments.length - 1];
          this.toggleView(true, callback);
          return this;
      },
  
      /**
       * The implementation for showing nodes.
       * Default is to toggle the style.display property.
       * @method _show
       * @protected
       * @chainable
       */
      _show: function() {
          this.setStyle('display', '');
  
      },
  
      _isHidden: function() {
          return Y.DOM.getStyle(this._node, 'display') === 'none';
      },
  
      /**
       * Displays or hides the node.
       * If the "transition" module is loaded, toggleView optionally
       * animates the toggling of the node using either the default
       * transition effect ('fadeIn'), or the given named effect.
       * @method toggleView
       * @for Node
       * @param {Boolean} [on] An optional boolean value to force the node to be shown or hidden
       * @param {Function} [callback] An optional function to run after the transition completes.
       * @chainable
       */
      toggleView: function(on, callback) {
          this._toggleView.apply(this, arguments);
          return this;
      },
  
      _toggleView: function(on, callback) {
          callback = arguments[arguments.length - 1];
  
          // base on current state if not forcing
          if (typeof on != 'boolean') {
              on = (this._isHidden()) ? 1 : 0;
          }
  
          if (on) {
              this._show();
          }  else {
              this._hide();
          }
  
          if (typeof callback == 'function') {
              callback.call(this);
          }
  
          return this;
      },
  
      /**
       * Hides the node.
       * If the "transition" module is loaded, hide optionally
       * animates the hiding of the node using either the default
       * transition effect ('fadeOut'), or the given named effect.
       * @method hide
       * @param {String} name A named Transition effect to use as the show effect.
       * @param {Object} config Options to use with the transition.
       * @param {Function} callback An optional function to run after the transition completes.
       * @chainable
       */
      hide: function(callback) {
          callback = arguments[arguments.length - 1];
          this.toggleView(false, callback);
          return this;
      },
  
      /**
       * The implementation for hiding nodes.
       * Default is to toggle the style.display property.
       * @method _hide
       * @protected
       * @chainable
       */
      _hide: function() {
          this.setStyle('display', 'none');
      }
  });
  
  Y.NodeList.importMethod(Y.Node.prototype, [
      /**
       * Makes each node visible.
       * If the "transition" module is loaded, show optionally
       * animates the showing of the node using either the default
       * transition effect ('fadeIn'), or the given named effect.
       * @method show
       * @param {String} name A named Transition effect to use as the show effect.
       * @param {Object} config Options to use with the transition.
       * @param {Function} callback An optional function to run after the transition completes.
       * @for NodeList
       * @chainable
       */
      'show',
  
      /**
       * Hides each node.
       * If the "transition" module is loaded, hide optionally
       * animates the hiding of the node using either the default
       * transition effect ('fadeOut'), or the given named effect.
       * @method hide
       * @param {String} name A named Transition effect to use as the show effect.
       * @param {Object} config Options to use with the transition.
       * @param {Function} callback An optional function to run after the transition completes.
       * @chainable
       */
      'hide',
  
      /**
       * Displays or hides each node.
       * If the "transition" module is loaded, toggleView optionally
       * animates the toggling of the nodes using either the default
       * transition effect ('fadeIn'), or the given named effect.
       * @method toggleView
       * @param {Boolean} [on] An optional boolean value to force the nodes to be shown or hidden
       * @param {Function} [callback] An optional function to run after the transition completes.
       * @chainable
       */
      'toggleView'
  ]);
  
  if (!Y.config.doc.documentElement.hasAttribute) { // IE < 8
      Y.Node.prototype.hasAttribute = function(attr) {
          if (attr === 'value') {
              if (this.get('value') !== "") { // IE < 8 fails to populate specified when set in HTML
                  return true;
              }
          }
          return !!(this._node.attributes[attr] &&
                  this._node.attributes[attr].specified);
      };
  }
  
  // IE throws an error when calling focus() on an element that's invisible, not
  // displayed, or disabled.
  Y.Node.prototype.focus = function () {
      try {
          this._node.focus();
      } catch (e) {
      }
  
      return this;
  };
  
  // IE throws error when setting input.type = 'hidden',
  // input.setAttribute('type', 'hidden') and input.attributes.type.value = 'hidden'
  Y.Node.ATTRS.type = {
      setter: function(val) {
          if (val === 'hidden') {
              try {
                  this._node.type = 'hidden';
              } catch(e) {
                  this.setStyle('display', 'none');
                  this._inputType = 'hidden';
              }
          } else {
              try { // IE errors when changing the type from "hidden'
                  this._node.type = val;
              } catch (e) {
              }
          }
          return val;
      },
  
      getter: function() {
          return this._inputType || this._node.type;
      },
  
      _bypassProxy: true // don't update DOM when using with Attribute
  };
  
  if (Y.config.doc.createElement('form').elements.nodeType) {
      // IE: elements collection is also FORM node which trips up scrubVal.
      Y.Node.ATTRS.elements = {
              getter: function() {
                  return this.all('input, textarea, button, select');
              }
      };
  }
  
  /**
   * Provides methods for managing custom Node data.
   * 
   * @module node
   * @main node
   * @submodule node-data
   */
  
  Y.mix(Y.Node.prototype, {
      _initData: function() {
          if (! ('_data' in this)) {
              this._data = {};
          }
      },
  
      /**
      * @method getData
      * @for Node
      * @description Retrieves arbitrary data stored on a Node instance.
      * If no data is associated with the Node, it will attempt to retrieve
      * a value from the corresponding HTML data attribute. (e.g. node.getData('foo')
      * will check node.getAttribute('data-foo')).
      * @param {string} name Optional name of the data field to retrieve.
      * If no name is given, all data is returned.
      * @return {any | Object} Whatever is stored at the given field,
      * or an object hash of all fields.
      */
      getData: function(name) {
          this._initData();
          var data = this._data,
              ret = data;
  
          if (arguments.length) { // single field
              if (name in data) {
                  ret = data[name];
              } else { // initialize from HTML attribute
                  ret = this._getDataAttribute(name);
              }
          } else if (typeof data == 'object' && data !== null) { // all fields
              ret = {};
              Y.Object.each(data, function(v, n) {
                  ret[n] = v;
              });
  
              ret = this._getDataAttributes(ret);
          }
  
          return ret;
  
      },
  
      _getDataAttributes: function(ret) {
          ret = ret || {};
          var i = 0,
              attrs = this._node.attributes,
              len = attrs.length,
              prefix = this.DATA_PREFIX,
              prefixLength = prefix.length,
              name;
  
          while (i < len) {
              name = attrs[i].name;
              if (name.indexOf(prefix) === 0) {
                  name = name.substr(prefixLength);
                  if (!(name in ret)) { // only merge if not already stored
                      ret[name] = this._getDataAttribute(name);
                  }
              }
  
              i += 1;
          }
  
          return ret;
      },
  
      _getDataAttribute: function(name) {
          var name = this.DATA_PREFIX + name,
              node = this._node,
              attrs = node.attributes,
              data = attrs && attrs[name] && attrs[name].value;
  
          return data;
      },
  
      /**
      * @method setData
      * @for Node
      * @description Stores arbitrary data on a Node instance.
      * This is not stored with the DOM node.
      * @param {string} name The name of the field to set. If no val
      * is given, name is treated as the data and overrides any existing data.
      * @param {any} val The value to be assigned to the field.
      * @chainable
      */
      setData: function(name, val) {
          this._initData();
          if (arguments.length > 1) {
              this._data[name] = val;
          } else {
              this._data = name;
          }
  
         return this;
      },
  
      /**
      * @method clearData
      * @for Node
      * @description Clears internally stored data.
      * @param {string} name The name of the field to clear. If no name
      * is given, all data is cleared.
      * @chainable
      */
      clearData: function(name) {
          if ('_data' in this) {
              if (typeof name != 'undefined') {
                  delete this._data[name];
              } else {
                  delete this._data;
              }
          }
  
          return this;
      }
  });
  
  Y.mix(Y.NodeList.prototype, {
      /**
      * @method getData
      * @for NodeList
      * @description Retrieves arbitrary data stored on each Node instance
      * bound to the NodeList.
      * @see Node
      * @param {string} name Optional name of the data field to retrieve.
      * If no name is given, all data is returned.
      * @return {Array} An array containing all of the data for each Node instance. 
      * or an object hash of all fields.
      */
      getData: function(name) {
          var args = (arguments.length) ? [name] : [];
          return this._invoke('getData', args, true);
      },
  
      /**
      * @method setData
      * @for NodeList
      * @description Stores arbitrary data on each Node instance bound to the
      *  NodeList. This is not stored with the DOM node.
      * @param {string} name The name of the field to set. If no name
      * is given, name is treated as the data and overrides any existing data.
      * @param {any} val The value to be assigned to the field.
      * @chainable
      */
      setData: function(name, val) {
          var args = (arguments.length > 1) ? [name, val] : [name];
          return this._invoke('setData', args);
      },
  
      /**
      * @method clearData
      * @for NodeList
      * @description Clears data on all Node instances bound to the NodeList.
      * @param {string} name The name of the field to clear. If no name
      * is given, all data is cleared.
      * @chainable
      */
      clearData: function(name) {
          var args = (arguments.length) ? [name] : [];
          return this._invoke('clearData', [name]);
      }
  });
  
  
  }, '@VERSION@' ,{requires:['dom-base', 'node-core', 'event-base']});
  (function () {
  var GLOBAL_ENV = YUI.Env;
  
  if (!GLOBAL_ENV._ready) {
      GLOBAL_ENV._ready = function() {
          GLOBAL_ENV.DOMReady = true;
          GLOBAL_ENV.remove(YUI.config.doc, 'DOMContentLoaded', GLOBAL_ENV._ready);
      };
  
      GLOBAL_ENV.add(YUI.config.doc, 'DOMContentLoaded', GLOBAL_ENV._ready);
  }
  })();
  YUI.add('event-base', function(Y) {
  
  /*
   * DOM event listener abstraction layer
   * @module event
   * @submodule event-base
   */
  
  /**
   * The domready event fires at the moment the browser's DOM is
   * usable. In most cases, this is before images are fully
   * downloaded, allowing you to provide a more responsive user
   * interface.
   *
   * In YUI 3, domready subscribers will be notified immediately if
   * that moment has already passed when the subscription is created.
   *
   * One exception is if the yui.js file is dynamically injected into
   * the page.  If this is done, you must tell the YUI instance that
   * you did this in order for DOMReady (and window load events) to
   * fire normally.  That configuration option is 'injected' -- set
   * it to true if the yui.js script is not included inline.
   *
   * This method is part of the 'event-ready' module, which is a
   * submodule of 'event'.
   *
   * @event domready
   * @for YUI
   */
  Y.publish('domready', {
      fireOnce: true,
      async: true
  });
  
  if (YUI.Env.DOMReady) {
      Y.fire('domready');
  } else {
      Y.Do.before(function() { Y.fire('domready'); }, YUI.Env, '_ready');
  }
  
  /**
   * Custom event engine, DOM event listener abstraction layer, synthetic DOM
   * events.
   * @module event
   * @submodule event-base
   */
  
  /**
   * Wraps a DOM event, properties requiring browser abstraction are
   * fixed here.  Provids a security layer when required.
   * @class DOMEventFacade
   * @param ev {Event} the DOM event
   * @param currentTarget {HTMLElement} the element the listener was attached to
   * @param wrapper {Event.Custom} the custom event wrapper for this DOM event
   */
  
      var ua = Y.UA,
  
      EMPTY = {},
  
      /**
       * webkit key remapping required for Safari < 3.1
       * @property webkitKeymap
       * @private
       */
      webkitKeymap = {
          63232: 38, // up
          63233: 40, // down
          63234: 37, // left
          63235: 39, // right
          63276: 33, // page up
          63277: 34, // page down
          25:     9, // SHIFT-TAB (Safari provides a different key code in
                     // this case, even though the shiftKey modifier is set)
          63272: 46, // delete
          63273: 36, // home
          63275: 35  // end
      },
  
      /**
       * Returns a wrapped node.  Intended to be used on event targets,
       * so it will return the node's parent if the target is a text
       * node.
       *
       * If accessing a property of the node throws an error, this is
       * probably the anonymous div wrapper Gecko adds inside text
       * nodes.  This likely will only occur when attempting to access
       * the relatedTarget.  In this case, we now return null because
       * the anonymous div is completely useless and we do not know
       * what the related target was because we can't even get to
       * the element's parent node.
       *
       * @method resolve
       * @private
       */
      resolve = function(n) {
          if (!n) {
              return n;
          }
          try {
              if (n && 3 == n.nodeType) {
                  n = n.parentNode;
              }
          } catch(e) {
              return null;
          }
  
          return Y.one(n);
      },
  
      DOMEventFacade = function(ev, currentTarget, wrapper) {
          this._event = ev;
          this._currentTarget = currentTarget;
          this._wrapper = wrapper || EMPTY;
  
          // if not lazy init
          this.init();
      };
  
  Y.extend(DOMEventFacade, Object, {
  
      init: function() {
  
          var e = this._event,
              overrides = this._wrapper.overrides,
              x = e.pageX,
              y = e.pageY,
              c,
              currentTarget = this._currentTarget;
  
          this.altKey   = e.altKey;
          this.ctrlKey  = e.ctrlKey;
          this.metaKey  = e.metaKey;
          this.shiftKey = e.shiftKey;
          this.type     = (overrides && overrides.type) || e.type;
          this.clientX  = e.clientX;
          this.clientY  = e.clientY;
  
          this.pageX = x;
          this.pageY = y;
  
          // charCode is unknown in keyup, keydown. keyCode is unknown in keypress.
          // FF 3.6 - 8+? pass 0 for keyCode in keypress events.
          // Webkit, FF 3.6-8+?, and IE9+? pass 0 for charCode in keydown, keyup.
          // Webkit and IE9+? duplicate charCode in keyCode.
          // Opera never sets charCode, always keyCode (though with the charCode).
          // IE6-8 don't set charCode or which.
          // All browsers other than IE6-8 set which=keyCode in keydown, keyup, and 
          // which=charCode in keypress.
          //
          // Moral of the story: (e.which || e.keyCode) will always return the
          // known code for that key event phase. e.keyCode is often different in
          // keypress from keydown and keyup.
          c = e.keyCode || e.charCode;
  
          if (ua.webkit && (c in webkitKeymap)) {
              c = webkitKeymap[c];
          }
  
          this.keyCode = c;
          this.charCode = c;
          // Fill in e.which for IE - implementers should always use this over
          // e.keyCode or e.charCode.
          this.which = e.which || e.charCode || c;
          // this.button = e.button;
          this.button = this.which;
  
          this.target = resolve(e.target);
          this.currentTarget = resolve(currentTarget);
          this.relatedTarget = resolve(e.relatedTarget);
  
          if (e.type == "mousewheel" || e.type == "DOMMouseScroll") {
              this.wheelDelta = (e.detail) ? (e.detail * -1) : Math.round(e.wheelDelta / 80) || ((e.wheelDelta < 0) ? -1 : 1);
          }
  
          if (this._touch) {
              this._touch(e, currentTarget, this._wrapper);
          }
      },
  
      stopPropagation: function() {
          this._event.stopPropagation();
          this._wrapper.stopped = 1;
          this.stopped = 1;
      },
  
      stopImmediatePropagation: function() {
          var e = this._event;
          if (e.stopImmediatePropagation) {
              e.stopImmediatePropagation();
          } else {
              this.stopPropagation();
          }
          this._wrapper.stopped = 2;
          this.stopped = 2;
      },
  
      preventDefault: function(returnValue) {
          var e = this._event;
          e.preventDefault();
          e.returnValue = returnValue || false;
          this._wrapper.prevented = 1;
          this.prevented = 1;
      },
  
      halt: function(immediate) {
          if (immediate) {
              this.stopImmediatePropagation();
          } else {
              this.stopPropagation();
          }
  
          this.preventDefault();
      }
  
  });
  
  DOMEventFacade.resolve = resolve;
  Y.DOM2EventFacade = DOMEventFacade;
  Y.DOMEventFacade = DOMEventFacade;
  
      /**
       * The native event
       * @property _event
       * @type {Native DOM Event}
       * @private
       */
  
      /**
      The name of the event (e.g. "click")
  
      @property type
      @type {String}
      **/
  
      /**
      `true` if the "alt" or "option" key is pressed.
  
      @property altKey
      @type {Boolean}
      **/
  
      /**
      `true` if the shift key is pressed.
  
      @property shiftKey
      @type {Boolean}
      **/
  
      /**
      `true` if the "Windows" key on a Windows keyboard, "command" key on an
      Apple keyboard, or "meta" key on other keyboards is pressed.
  
      @property metaKey
      @type {Boolean}
      **/
  
      /**
      `true` if the "Ctrl" or "control" key is pressed.
  
      @property ctrlKey
      @type {Boolean}
      **/
  
      /**
       * The X location of the event on the page (including scroll)
       * @property pageX
       * @type {Number}
       */
  
      /**
       * The Y location of the event on the page (including scroll)
       * @property pageY
       * @type {Number}
       */
  
      /**
       * The X location of the event in the viewport
       * @property clientX
       * @type {Number}
       */
  
      /**
       * The Y location of the event in the viewport
       * @property clientY
       * @type {Number}
       */
  
      /**
       * The keyCode for key events.  Uses charCode if keyCode is not available
       * @property keyCode
       * @type {Number}
       */
  
      /**
       * The charCode for key events.  Same as keyCode
       * @property charCode
       * @type {Number}
       */
  
      /**
       * The button that was pushed. 1 for left click, 2 for middle click, 3 for
       * right click.  This is only reliably populated on `mouseup` events.
       * @property button
       * @type {Number}
       */
  
      /**
       * The button that was pushed.  Same as button.
       * @property which
       * @type {Number}
       */
  
      /**
       * Node reference for the targeted element
       * @property target
       * @type {Node}
       */
  
      /**
       * Node reference for the element that the listener was attached to.
       * @property currentTarget
       * @type {Node}
       */
  
      /**
       * Node reference to the relatedTarget
       * @property relatedTarget
       * @type {Node}
       */
  
      /**
       * Number representing the direction and velocity of the movement of the mousewheel.
       * Negative is down, the higher the number, the faster.  Applies to the mousewheel event.
       * @property wheelDelta
       * @type {Number}
       */
  
      /**
       * Stops the propagation to the next bubble target
       * @method stopPropagation
       */
  
      /**
       * Stops the propagation to the next bubble target and
       * prevents any additional listeners from being exectued
       * on the current target.
       * @method stopImmediatePropagation
       */
  
      /**
       * Prevents the event's default behavior
       * @method preventDefault
       * @param returnValue {string} sets the returnValue of the event to this value
       * (rather than the default false value).  This can be used to add a customized
       * confirmation query to the beforeunload event).
       */
  
      /**
       * Stops the event propagation and prevents the default
       * event behavior.
       * @method halt
       * @param immediate {boolean} if true additional listeners
       * on the current target will not be executed
       */
  (function() {
  /**
   * The event utility provides functions to add and remove event listeners,
   * event cleansing.  It also tries to automatically remove listeners it
   * registers during the unload event.
   * @module event
   * @main event
   * @submodule event-base
   */
  
  /**
   * The event utility provides functions to add and remove event listeners,
   * event cleansing.  It also tries to automatically remove listeners it
   * registers during the unload event.
   *
   * @class Event
   * @static
   */
  
  Y.Env.evt.dom_wrappers = {};
  Y.Env.evt.dom_map = {};
  
  var _eventenv = Y.Env.evt,
      config = Y.config,
      win = config.win,
      add = YUI.Env.add,
      remove = YUI.Env.remove,
  
      onLoad = function() {
          YUI.Env.windowLoaded = true;
          Y.Event._load();
          remove(win, "load", onLoad);
      },
  
      onUnload = function() {
          Y.Event._unload();
      },
  
      EVENT_READY = 'domready',
  
      COMPAT_ARG = '~yui|2|compat~',
  
      shouldIterate = function(o) {
          try {
              return (o && typeof o !== "string" && Y.Lang.isNumber(o.length) &&
                      !o.tagName && !o.alert);
          } catch(ex) {
              return false;
          }
  
      },
  
      // aliases to support DOM event subscription clean up when the last
      // subscriber is detached. deleteAndClean overrides the DOM event's wrapper
      // CustomEvent _delete method.
      _ceProtoDelete = Y.CustomEvent.prototype._delete,
      _deleteAndClean = function(s) {
          var ret = _ceProtoDelete.apply(this, arguments);
  
          if (!this.subCount && !this.afterCount) {
              Y.Event._clean(this);
          }
  
          return ret;
      },
  
  Event = function() {
  
      /**
       * True after the onload event has fired
       * @property _loadComplete
       * @type boolean
       * @static
       * @private
       */
      var _loadComplete =  false,
  
      /**
       * The number of times to poll after window.onload.  This number is
       * increased if additional late-bound handlers are requested after
       * the page load.
       * @property _retryCount
       * @static
       * @private
       */
      _retryCount = 0,
  
      /**
       * onAvailable listeners
       * @property _avail
       * @static
       * @private
       */
      _avail = [],
  
      /**
       * Custom event wrappers for DOM events.  Key is
       * 'event:' + Element uid stamp + event type
       * @property _wrappers
       * @type Y.Event.Custom
       * @static
       * @private
       */
      _wrappers = _eventenv.dom_wrappers,
  
      _windowLoadKey = null,
  
      /**
       * Custom event wrapper map DOM events.  Key is
       * Element uid stamp.  Each item is a hash of custom event
       * wrappers as provided in the _wrappers collection.  This
       * provides the infrastructure for getListeners.
       * @property _el_events
       * @static
       * @private
       */
      _el_events = _eventenv.dom_map;
  
      return {
  
          /**
           * The number of times we should look for elements that are not
           * in the DOM at the time the event is requested after the document
           * has been loaded.  The default is 1000@amp;40 ms, so it will poll
           * for 40 seconds or until all outstanding handlers are bound
           * (whichever comes first).
           * @property POLL_RETRYS
           * @type int
           * @static
           * @final
           */
          POLL_RETRYS: 1000,
  
          /**
           * The poll interval in milliseconds
           * @property POLL_INTERVAL
           * @type int
           * @static
           * @final
           */
          POLL_INTERVAL: 40,
  
          /**
           * addListener/removeListener can throw errors in unexpected scenarios.
           * These errors are suppressed, the method returns false, and this property
           * is set
           * @property lastError
           * @static
           * @type Error
           */
          lastError: null,
  
  
          /**
           * poll handle
           * @property _interval
           * @static
           * @private
           */
          _interval: null,
  
          /**
           * document readystate poll handle
           * @property _dri
           * @static
           * @private
           */
           _dri: null,
  
          /**
           * True when the document is initially usable
           * @property DOMReady
           * @type boolean
           * @static
           */
          DOMReady: false,
  
          /**
           * @method startInterval
           * @static
           * @private
           */
          startInterval: function() {
              if (!Event._interval) {
  Event._interval = setInterval(Event._poll, Event.POLL_INTERVAL);
              }
          },
  
          /**
           * Executes the supplied callback when the item with the supplied
           * id is found.  This is meant to be used to execute behavior as
           * soon as possible as the page loads.  If you use this after the
           * initial page load it will poll for a fixed time for the element.
           * The number of times it will poll and the frequency are
           * configurable.  By default it will poll for 10 seconds.
           *
           * <p>The callback is executed with a single parameter:
           * the custom object parameter, if provided.</p>
           *
           * @method onAvailable
           *
           * @param {string||string[]}   id the id of the element, or an array
           * of ids to look for.
           * @param {function} fn what to execute when the element is found.
           * @param {object}   p_obj an optional object to be passed back as
           *                   a parameter to fn.
           * @param {boolean|object}  p_override If set to true, fn will execute
           *                   in the context of p_obj, if set to an object it
           *                   will execute in the context of that object
           * @param checkContent {boolean} check child node readiness (onContentReady)
           * @static
           * @deprecated Use Y.on("available")
           */
          // @TODO fix arguments
          onAvailable: function(id, fn, p_obj, p_override, checkContent, compat) {
  
              var a = Y.Array(id), i, availHandle;
  
  
              for (i=0; i<a.length; i=i+1) {
                  _avail.push({
                      id:         a[i],
                      fn:         fn,
                      obj:        p_obj,
                      override:   p_override,
                      checkReady: checkContent,
                      compat:     compat
                  });
              }
              _retryCount = this.POLL_RETRYS;
  
              // We want the first test to be immediate, but async
              setTimeout(Event._poll, 0);
  
              availHandle = new Y.EventHandle({
  
                  _delete: function() {
                      // set by the event system for lazy DOM listeners
                      if (availHandle.handle) {
                          availHandle.handle.detach();
                          return;
                      }
  
                      var i, j;
  
                      // otherwise try to remove the onAvailable listener(s)
                      for (i = 0; i < a.length; i++) {
                          for (j = 0; j < _avail.length; j++) {
                              if (a[i] === _avail[j].id) {
                                  _avail.splice(j, 1);
                              }
                          }
                      }
                  }
  
              });
  
              return availHandle;
          },
  
          /**
           * Works the same way as onAvailable, but additionally checks the
           * state of sibling elements to determine if the content of the
           * available element is safe to modify.
           *
           * <p>The callback is executed with a single parameter:
           * the custom object parameter, if provided.</p>
           *
           * @method onContentReady
           *
           * @param {string}   id the id of the element to look for.
           * @param {function} fn what to execute when the element is ready.
           * @param {object}   obj an optional object to be passed back as
           *                   a parameter to fn.
           * @param {boolean|object}  override If set to true, fn will execute
           *                   in the context of p_obj.  If an object, fn will
           *                   exectute in the context of that object
           *
           * @static
           * @deprecated Use Y.on("contentready")
           */
          // @TODO fix arguments
          onContentReady: function(id, fn, obj, override, compat) {
              return Event.onAvailable(id, fn, obj, override, true, compat);
          },
  
          /**
           * Adds an event listener
           *
           * @method attach
           *
           * @param {String}   type     The type of event to append
           * @param {Function} fn        The method the event invokes
           * @param {String|HTMLElement|Array|NodeList} el An id, an element
           *  reference, or a collection of ids and/or elements to assign the
           *  listener to.
           * @param {Object}   context optional context object
           * @param {Boolean|object}  args 0..n arguments to pass to the callback
           * @return {EventHandle} an object to that can be used to detach the listener
           *
           * @static
           */
  
          attach: function(type, fn, el, context) {
              return Event._attach(Y.Array(arguments, 0, true));
          },
  
          _createWrapper: function (el, type, capture, compat, facade) {
  
              var cewrapper,
                  ek  = Y.stamp(el),
                  key = 'event:' + ek + type;
  
              if (false === facade) {
                  key += 'native';
              }
              if (capture) {
                  key += 'capture';
              }
  
  
              cewrapper = _wrappers[key];
  
  
              if (!cewrapper) {
                  // create CE wrapper
                  cewrapper = Y.publish(key, {
                      silent: true,
                      bubbles: false,
                      contextFn: function() {
                          if (compat) {
                              return cewrapper.el;
                          } else {
                              cewrapper.nodeRef = cewrapper.nodeRef || Y.one(cewrapper.el);
                              return cewrapper.nodeRef;
                          }
                      }
                  });
  
                  cewrapper.overrides = {};
  
                  // for later removeListener calls
                  cewrapper.el = el;
                  cewrapper.key = key;
                  cewrapper.domkey = ek;
                  cewrapper.type = type;
                  cewrapper.fn = function(e) {
                      cewrapper.fire(Event.getEvent(e, el, (compat || (false === facade))));
                  };
                  cewrapper.capture = capture;
  
                  if (el == win && type == "load") {
                      // window load happens once
                      cewrapper.fireOnce = true;
                      _windowLoadKey = key;
                  }
                  cewrapper._delete = _deleteAndClean;
  
                  _wrappers[key] = cewrapper;
                  _el_events[ek] = _el_events[ek] || {};
                  _el_events[ek][key] = cewrapper;
  
                  add(el, type, cewrapper.fn, capture);
              }
  
              return cewrapper;
  
          },
  
          _attach: function(args, conf) {
  
              var compat,
                  handles, oEl, cewrapper, context,
                  fireNow = false, ret,
                  type = args[0],
                  fn = args[1],
                  el = args[2] || win,
                  facade = conf && conf.facade,
                  capture = conf && conf.capture,
                  overrides = conf && conf.overrides;
  
              if (args[args.length-1] === COMPAT_ARG) {
                  compat = true;
              }
  
              if (!fn || !fn.call) {
  // throw new TypeError(type + " attach call failed, callback undefined");
                  return false;
              }
  
              // The el argument can be an array of elements or element ids.
              if (shouldIterate(el)) {
  
                  handles=[];
  
                  Y.each(el, function(v, k) {
                      args[2] = v;
                      handles.push(Event._attach(args.slice(), conf));
                  });
  
                  // return (handles.length === 1) ? handles[0] : handles;
                  return new Y.EventHandle(handles);
  
              // If the el argument is a string, we assume it is
              // actually the id of the element.  If the page is loaded
              // we convert el to the actual element, otherwise we
              // defer attaching the event until the element is
              // ready
              } else if (Y.Lang.isString(el)) {
  
                  // oEl = (compat) ? Y.DOM.byId(el) : Y.Selector.query(el);
  
                  if (compat) {
                      oEl = Y.DOM.byId(el);
                  } else {
  
                      oEl = Y.Selector.query(el);
  
                      switch (oEl.length) {
                          case 0:
                              oEl = null;
                              break;
                          case 1:
                              oEl = oEl[0];
                              break;
                          default:
                              args[2] = oEl;
                              return Event._attach(args, conf);
                      }
                  }
  
                  if (oEl) {
  
                      el = oEl;
  
                  // Not found = defer adding the event until the element is available
                  } else {
  
                      ret = Event.onAvailable(el, function() {
  
                          ret.handle = Event._attach(args, conf);
  
                      }, Event, true, false, compat);
  
                      return ret;
  
                  }
              }
  
              // Element should be an html element or node
              if (!el) {
                  return false;
              }
  
              if (Y.Node && Y.instanceOf(el, Y.Node)) {
                  el = Y.Node.getDOMNode(el);
              }
  
              cewrapper = Event._createWrapper(el, type, capture, compat, facade);
              if (overrides) {
                  Y.mix(cewrapper.overrides, overrides);
              }
  
              if (el == win && type == "load") {
  
                  // if the load is complete, fire immediately.
                  // all subscribers, including the current one
                  // will be notified.
                  if (YUI.Env.windowLoaded) {
                      fireNow = true;
                  }
              }
  
              if (compat) {
                  args.pop();
              }
  
              context = args[3];
  
              // set context to the Node if not specified
              // ret = cewrapper.on.apply(cewrapper, trimmedArgs);
              ret = cewrapper._on(fn, context, (args.length > 4) ? args.slice(4) : null);
  
              if (fireNow) {
                  cewrapper.fire();
              }
  
              return ret;
  
          },
  
          /**
           * Removes an event listener.  Supports the signature the event was bound
           * with, but the preferred way to remove listeners is using the handle
           * that is returned when using Y.on
           *
           * @method detach
           *
           * @param {String} type the type of event to remove.
           * @param {Function} fn the method the event invokes.  If fn is
           * undefined, then all event handlers for the type of event are
           * removed.
           * @param {String|HTMLElement|Array|NodeList|EventHandle} el An
           * event handle, an id, an element reference, or a collection
           * of ids and/or elements to remove the listener from.
           * @return {boolean} true if the unbind was successful, false otherwise.
           * @static
           */
          detach: function(type, fn, el, obj) {
  
              var args=Y.Array(arguments, 0, true), compat, l, ok, i,
                  id, ce;
  
              if (args[args.length-1] === COMPAT_ARG) {
                  compat = true;
                  // args.pop();
              }
  
              if (type && type.detach) {
                  return type.detach();
              }
  
              // The el argument can be a string
              if (typeof el == "string") {
  
                  // el = (compat) ? Y.DOM.byId(el) : Y.all(el);
                  if (compat) {
                      el = Y.DOM.byId(el);
                  } else {
                      el = Y.Selector.query(el);
                      l = el.length;
                      if (l < 1) {
                          el = null;
                      } else if (l == 1) {
                          el = el[0];
                      }
                  }
                  // return Event.detach.apply(Event, args);
              }
  
              if (!el) {
                  return false;
              }
  
              if (el.detach) {
                  args.splice(2, 1);
                  return el.detach.apply(el, args);
              // The el argument can be an array of elements or element ids.
              } else if (shouldIterate(el)) {
                  ok = true;
                  for (i=0, l=el.length; i<l; ++i) {
                      args[2] = el[i];
                      ok = ( Y.Event.detach.apply(Y.Event, args) && ok );
                  }
  
                  return ok;
              }
  
              if (!type || !fn || !fn.call) {
                  return Event.purgeElement(el, false, type);
              }
  
              id = 'event:' + Y.stamp(el) + type;
              ce = _wrappers[id];
  
              if (ce) {
                  return ce.detach(fn);
              } else {
                  return false;
              }
  
          },
  
          /**
           * Finds the event in the window object, the caller's arguments, or
           * in the arguments of another method in the callstack.  This is
           * executed automatically for events registered through the event
           * manager, so the implementer should not normally need to execute
           * this function at all.
           * @method getEvent
           * @param {Event} e the event parameter from the handler
           * @param {HTMLElement} el the element the listener was attached to
           * @return {Event} the event
           * @static
           */
          getEvent: function(e, el, noFacade) {
              var ev = e || win.event;
  
              return (noFacade) ? ev :
                  new Y.DOMEventFacade(ev, el, _wrappers['event:' + Y.stamp(el) + e.type]);
          },
  
          /**
           * Generates an unique ID for the element if it does not already
           * have one.
           * @method generateId
           * @param el the element to create the id for
           * @return {string} the resulting id of the element
           * @static
           */
          generateId: function(el) {
              return Y.DOM.generateID(el);
          },
  
          /**
           * We want to be able to use getElementsByTagName as a collection
           * to attach a group of events to.  Unfortunately, different
           * browsers return different types of collections.  This function
           * tests to determine if the object is array-like.  It will also
           * fail if the object is an array, but is empty.
           * @method _isValidCollection
           * @param o the object to test
           * @return {boolean} true if the object is array-like and populated
           * @deprecated was not meant to be used directly
           * @static
           * @private
           */
          _isValidCollection: shouldIterate,
  
          /**
           * hook up any deferred listeners
           * @method _load
           * @static
           * @private
           */
          _load: function(e) {
              if (!_loadComplete) {
                  _loadComplete = true;
  
                  // Just in case DOMReady did not go off for some reason
                  // E._ready();
                  if (Y.fire) {
                      Y.fire(EVENT_READY);
                  }
  
                  // Available elements may not have been detected before the
                  // window load event fires. Try to find them now so that the
                  // the user is more likely to get the onAvailable notifications
                  // before the window load notification
                  Event._poll();
              }
          },
  
          /**
           * Polling function that runs before the onload event fires,
           * attempting to attach to DOM Nodes as soon as they are
           * available
           * @method _poll
           * @static
           * @private
           */
          _poll: function() {
              if (Event.locked) {
                  return;
              }
  
              if (Y.UA.ie && !YUI.Env.DOMReady) {
                  // Hold off if DOMReady has not fired and check current
                  // readyState to protect against the IE operation aborted
                  // issue.
                  Event.startInterval();
                  return;
              }
  
              Event.locked = true;
  
              // keep trying until after the page is loaded.  We need to
              // check the page load state prior to trying to bind the
              // elements so that we can be certain all elements have been
              // tested appropriately
              var i, len, item, el, notAvail, executeItem,
                  tryAgain = !_loadComplete;
  
              if (!tryAgain) {
                  tryAgain = (_retryCount > 0);
              }
  
              // onAvailable
              notAvail = [];
  
              executeItem = function (el, item) {
                  var context, ov = item.override;
                  try {
                      if (item.compat) {
                          if (item.override) {
                              if (ov === true) {
                                  context = item.obj;
                              } else {
                                  context = ov;
                              }
                          } else {
                              context = el;
                          }
                          item.fn.call(context, item.obj);
                      } else {
                          context = item.obj || Y.one(el);
                          item.fn.apply(context, (Y.Lang.isArray(ov)) ? ov : []);
                      }
                  } catch (e) {
                  }
              };
  
              // onAvailable
              for (i=0,len=_avail.length; i<len; ++i) {
                  item = _avail[i];
                  if (item && !item.checkReady) {
  
                      // el = (item.compat) ? Y.DOM.byId(item.id) : Y.one(item.id);
                      el = (item.compat) ? Y.DOM.byId(item.id) : Y.Selector.query(item.id, null, true);
  
                      if (el) {
                          executeItem(el, item);
                          _avail[i] = null;
                      } else {
                          notAvail.push(item);
                      }
                  }
              }
  
              // onContentReady
              for (i=0,len=_avail.length; i<len; ++i) {
                  item = _avail[i];
                  if (item && item.checkReady) {
  
                      // el = (item.compat) ? Y.DOM.byId(item.id) : Y.one(item.id);
                      el = (item.compat) ? Y.DOM.byId(item.id) : Y.Selector.query(item.id, null, true);
  
                      if (el) {
                          // The element is available, but not necessarily ready
                          // @todo should we test parentNode.nextSibling?
                          if (_loadComplete || (el.get && el.get('nextSibling')) || el.nextSibling) {
                              executeItem(el, item);
                              _avail[i] = null;
                          }
                      } else {
                          notAvail.push(item);
                      }
                  }
              }
  
              _retryCount = (notAvail.length === 0) ? 0 : _retryCount - 1;
  
              if (tryAgain) {
                  // we may need to strip the nulled out items here
                  Event.startInterval();
              } else {
                  clearInterval(Event._interval);
                  Event._interval = null;
              }
  
              Event.locked = false;
  
              return;
  
          },
  
          /**
           * Removes all listeners attached to the given element via addListener.
           * Optionally, the node's children can also be purged.
           * Optionally, you can specify a specific type of event to remove.
           * @method purgeElement
           * @param {HTMLElement} el the element to purge
           * @param {boolean} recurse recursively purge this element's children
           * as well.  Use with caution.
           * @param {string} type optional type of listener to purge. If
           * left out, all listeners will be removed
           * @static
           */
          purgeElement: function(el, recurse, type) {
              // var oEl = (Y.Lang.isString(el)) ? Y.one(el) : el,
              var oEl = (Y.Lang.isString(el)) ?  Y.Selector.query(el, null, true) : el,
                  lis = Event.getListeners(oEl, type), i, len, children, child;
  
              if (recurse && oEl) {
                  lis = lis || [];
                  children = Y.Selector.query('*', oEl);
                  i = 0;
                  len = children.length;
                  for (; i < len; ++i) {
                      child = Event.getListeners(children[i], type);
                      if (child) {
                          lis = lis.concat(child);
                      }
                  }
              }
  
              if (lis) {
                  for (i = 0, len = lis.length; i < len; ++i) {
                      lis[i].detachAll();
                  }
              }
  
          },
  
          /**
           * Removes all object references and the DOM proxy subscription for
           * a given event for a DOM node.
           *
           * @method _clean
           * @param wrapper {CustomEvent} Custom event proxy for the DOM
           *                  subscription
           * @private
           * @static
           * @since 3.4.0
           */
          _clean: function (wrapper) {
              var key    = wrapper.key,
                  domkey = wrapper.domkey;
  
              remove(wrapper.el, wrapper.type, wrapper.fn, wrapper.capture);
              delete _wrappers[key];
              delete Y._yuievt.events[key];
              if (_el_events[domkey]) {
                  delete _el_events[domkey][key];
                  if (!Y.Object.size(_el_events[domkey])) {
                      delete _el_events[domkey];
                  }
              }
          },
  
          /**
           * Returns all listeners attached to the given element via addListener.
           * Optionally, you can specify a specific type of event to return.
           * @method getListeners
           * @param el {HTMLElement|string} the element or element id to inspect
           * @param type {string} optional type of listener to return. If
           * left out, all listeners will be returned
           * @return {CustomEvent} the custom event wrapper for the DOM event(s)
           * @static
           */
          getListeners: function(el, type) {
              var ek = Y.stamp(el, true), evts = _el_events[ek],
                  results=[] , key = (type) ? 'event:' + ek + type : null,
                  adapters = _eventenv.plugins;
  
              if (!evts) {
                  return null;
              }
  
              if (key) {
                  // look for synthetic events
                  if (adapters[type] && adapters[type].eventDef) {
                      key += '_synth';
                  }
  
                  if (evts[key]) {
                      results.push(evts[key]);
                  }
  
                  // get native events as well
                  key += 'native';
                  if (evts[key]) {
                      results.push(evts[key]);
                  }
  
              } else {
                  Y.each(evts, function(v, k) {
                      results.push(v);
                  });
              }
  
              return (results.length) ? results : null;
          },
  
          /**
           * Removes all listeners registered by pe.event.  Called
           * automatically during the unload event.
           * @method _unload
           * @static
           * @private
           */
          _unload: function(e) {
              Y.each(_wrappers, function(v, k) {
                  if (v.type == 'unload') {
                      v.fire(e);
                  }
                  v.detachAll();
              });
              remove(win, "unload", onUnload);
          },
  
          /**
           * Adds a DOM event directly without the caching, cleanup, context adj, etc
           *
           * @method nativeAdd
           * @param {HTMLElement} el      the element to bind the handler to
           * @param {string}      type   the type of event handler
           * @param {function}    fn      the callback to invoke
           * @param {boolen}      capture capture or bubble phase
           * @static
           * @private
           */
          nativeAdd: add,
  
          /**
           * Basic remove listener
           *
           * @method nativeRemove
           * @param {HTMLElement} el      the element to bind the handler to
           * @param {string}      type   the type of event handler
           * @param {function}    fn      the callback to invoke
           * @param {boolen}      capture capture or bubble phase
           * @static
           * @private
           */
          nativeRemove: remove
      };
  
  }();
  
  Y.Event = Event;
  
  if (config.injected || YUI.Env.windowLoaded) {
      onLoad();
  } else {
      add(win, "load", onLoad);
  }
  
  // Process onAvailable/onContentReady items when when the DOM is ready in IE
  if (Y.UA.ie) {
      Y.on(EVENT_READY, Event._poll);
  }
  
  add(win, "unload", onUnload);
  
  Event.Custom = Y.CustomEvent;
  Event.Subscriber = Y.Subscriber;
  Event.Target = Y.EventTarget;
  Event.Handle = Y.EventHandle;
  Event.Facade = Y.EventFacade;
  
  Event._poll();
  
  })();
  
  /**
   * DOM event listener abstraction layer
   * @module event
   * @submodule event-base
   */
  
  /**
   * Executes the callback as soon as the specified element
   * is detected in the DOM.  This function expects a selector
   * string for the element(s) to detect.  If you already have
   * an element reference, you don't need this event.
   * @event available
   * @param type {string} 'available'
   * @param fn {function} the callback function to execute.
   * @param el {string} an selector for the element(s) to attach
   * @param context optional argument that specifies what 'this' refers to.
   * @param args* 0..n additional arguments to pass on to the callback function.
   * These arguments will be added after the event object.
   * @return {EventHandle} the detach handle
   * @for YUI
   */
  Y.Env.evt.plugins.available = {
      on: function(type, fn, id, o) {
          var a = arguments.length > 4 ?  Y.Array(arguments, 4, true) : null;
          return Y.Event.onAvailable.call(Y.Event, id, fn, o, a);
      }
  };
  
  /**
   * Executes the callback as soon as the specified element
   * is detected in the DOM with a nextSibling property
   * (indicating that the element's children are available).
   * This function expects a selector
   * string for the element(s) to detect.  If you already have
   * an element reference, you don't need this event.
   * @event contentready
   * @param type {string} 'contentready'
   * @param fn {function} the callback function to execute.
   * @param el {string} an selector for the element(s) to attach.
   * @param context optional argument that specifies what 'this' refers to.
   * @param args* 0..n additional arguments to pass on to the callback function.
   * These arguments will be added after the event object.
   * @return {EventHandle} the detach handle
   * @for YUI
   */
  Y.Env.evt.plugins.contentready = {
      on: function(type, fn, id, o) {
          var a = arguments.length > 4 ? Y.Array(arguments, 4, true) : null;
          return Y.Event.onContentReady.call(Y.Event, id, fn, o, a);
      }
  };
  
  
  }, '@VERSION@' ,{requires:['event-custom-base']});
  YUI.add('pluginhost-base', function(Y) {
  
      /**
       * Provides the augmentable PluginHost interface, which can be added to any class.
       * @module pluginhost
       */
  
      /**
       * Provides the augmentable PluginHost interface, which can be added to any class.
       * @module pluginhost-base
       */
  
      /**
       * <p>
       * An augmentable class, which provides the augmented class with the ability to host plugins.
       * It adds <a href="#method_plug">plug</a> and <a href="#method_unplug">unplug</a> methods to the augmented class, which can 
       * be used to add or remove plugins from instances of the class.
       * </p>
       *
       * <p>Plugins can also be added through the constructor configuration object passed to the host class' constructor using
       * the "plugins" property. Supported values for the "plugins" property are those defined by the <a href="#method_plug">plug</a> method. 
       * 
       * For example the following code would add the AnimPlugin and IOPlugin to Overlay (the plugin host):
       * <xmp>
       * var o = new Overlay({plugins: [ AnimPlugin, {fn:IOPlugin, cfg:{section:"header"}}]});
       * </xmp>
       * </p>
       * <p>
       * Plug.Host's protected <a href="#method_initPlugins">_initPlugins</a> and <a href="#method_destroyPlugins">_destroyPlugins</a> 
       * methods should be invoked by the host class at the appropriate point in the host's lifecyle.  
       * </p>
       *
       * @class Plugin.Host
       */
  
      var L = Y.Lang;
  
      function PluginHost() {
          this._plugins = {};
      }
  
      PluginHost.prototype = {
  
          /**
           * Adds a plugin to the host object. This will instantiate the 
           * plugin and attach it to the configured namespace on the host object.
           *
           * @method plug
           * @chainable
           * @param P {Function | Object |Array} Accepts the plugin class, or an 
           * object with a "fn" property specifying the plugin class and 
           * a "cfg" property specifying the configuration for the Plugin.
           * <p>
           * Additionally an Array can also be passed in, with the above function or 
           * object values, allowing the user to add multiple plugins in a single call.
           * </p>
           * @param config (Optional) If the first argument is the plugin class, the second argument
           * can be the configuration for the plugin.
           * @return {Base} A reference to the host object
           */
          plug: function(Plugin, config) {
              var i, ln, ns;
  
              if (L.isArray(Plugin)) {
                  for (i = 0, ln = Plugin.length; i < ln; i++) {
                      this.plug(Plugin[i]);
                  }
              } else {
                  if (Plugin && !L.isFunction(Plugin)) {
                      config = Plugin.cfg;
                      Plugin = Plugin.fn;
                  }
  
                  // Plugin should be fn by now
                  if (Plugin && Plugin.NS) {
                      ns = Plugin.NS;
          
                      config = config || {};
                      config.host = this;
          
                      if (this.hasPlugin(ns)) {
                          // Update config
                          if (this[ns].setAttrs) {
                              this[ns].setAttrs(config);
                          }
                      } else {
                          // Create new instance
                          this[ns] = new Plugin(config);
                          this._plugins[ns] = Plugin;
                      }
                  }
              }
              return this;
          },
  
          /**
           * Removes a plugin from the host object. This will destroy the 
           * plugin instance and delete the namepsace from the host object. 
           *
           * @method unplug
           * @param {String | Function} plugin The namespace of the plugin, or the plugin class with the static NS namespace property defined. If not provided,
           * all registered plugins are unplugged.
           * @return {Base} A reference to the host object
           * @chainable
           */
          unplug: function(plugin) {
              var ns = plugin, 
                  plugins = this._plugins;
              
              if (plugin) {
                  if (L.isFunction(plugin)) {
                      ns = plugin.NS;
                      if (ns && (!plugins[ns] || plugins[ns] !== plugin)) {
                          ns = null;
                      }
                  }
          
                  if (ns) {
                      if (this[ns]) {
                          if (this[ns].destroy) {
                              this[ns].destroy();
                          }
                          delete this[ns];
                      }
                      if (plugins[ns]) {
                          delete plugins[ns];
                      }
                  }
              } else {
                  for (ns in this._plugins) {
                      if (this._plugins.hasOwnProperty(ns)) {
                          this.unplug(ns);
                      }
                  }
              }
              return this;
          },
  
          /**
           * Determines if a plugin has plugged into this host.
           *
           * @method hasPlugin
           * @param {String} ns The plugin's namespace
           * @return {Plugin} Returns a truthy value (the plugin instance) if present, or undefined if not.
           */
          hasPlugin : function(ns) {
              return (this._plugins[ns] && this[ns]);
          },
  
          /**
           * Initializes static plugins registered on the host (using the
           * Base.plug static method) and any plugins passed to the 
           * instance through the "plugins" configuration property.
           *
           * @method _initPlugins
           * @param {Config} config The configuration object with property name/value pairs.
           * @private
           */
          
          _initPlugins: function(config) {
              this._plugins = this._plugins || {};
  
              if (this._initConfigPlugins) {
                  this._initConfigPlugins(config);
              }
          },
  
          /**
           * Unplugs and destroys all plugins on the host
           * @method _destroyPlugins
           * @private
           */
          _destroyPlugins: function() {
              this.unplug();
          }
      };
  
      Y.namespace("Plugin").Host = PluginHost;
  
  
  }, '@VERSION@' ,{requires:['yui-base']});
  YUI.add('pluginhost-config', function(Y) {
  
      /**
       * Adds pluginhost constructor configuration and static configuration support
       * @submodule pluginhost-config
       */
  
      var PluginHost = Y.Plugin.Host,
          L = Y.Lang;
  
      /**
       * A protected initialization method, used by the host class to initialize
       * plugin configurations passed the constructor, through the config object.
       * 
       * Host objects should invoke this method at the appropriate time in their
       * construction lifecycle.
       * 
       * @method _initConfigPlugins
       * @param {Object} config The configuration object passed to the constructor
       * @protected
       * @for Plugin.Host
       */
      PluginHost.prototype._initConfigPlugins = function(config) {
  
          // Class Configuration
          var classes = (this._getClasses) ? this._getClasses() : [this.constructor],
              plug = [],
              unplug = {},
              constructor, i, classPlug, classUnplug, pluginClassName;
  
          // TODO: Room for optimization. Can we apply statically/unplug in same pass?
          for (i = classes.length - 1; i >= 0; i--) {
              constructor = classes[i];
  
              classUnplug = constructor._UNPLUG;
              if (classUnplug) {
                  // subclasses over-write
                  Y.mix(unplug, classUnplug, true);
              }
  
              classPlug = constructor._PLUG;
              if (classPlug) {
                  // subclasses over-write
                  Y.mix(plug, classPlug, true);
              }
          }
  
          for (pluginClassName in plug) {
              if (plug.hasOwnProperty(pluginClassName)) {
                  if (!unplug[pluginClassName]) {
                      this.plug(plug[pluginClassName]);
                  }
              }
          }
  
          // User Configuration
          if (config && config.plugins) {
              this.plug(config.plugins);
          }
      };
      
      /**
       * Registers plugins to be instantiated at the class level (plugins 
       * which should be plugged into every instance of the class by default).
       *
       * @method plug
       * @static
       *
       * @param {Function} hostClass The host class on which to register the plugins
       * @param {Function | Array} plugin Either the plugin class, an array of plugin classes or an array of objects (with fn and cfg properties defined)
       * @param {Object} config (Optional) If plugin is the plugin class, the configuration for the plugin
       * @for Plugin.Host
       */
      PluginHost.plug = function(hostClass, plugin, config) {
          // Cannot plug into Base, since Plugins derive from Base [ will cause infinite recurrsion ]
          var p, i, l, name;
      
          if (hostClass !== Y.Base) {
              hostClass._PLUG = hostClass._PLUG || {};
      
              if (!L.isArray(plugin)) {
                  if (config) {
                      plugin = {fn:plugin, cfg:config};
                  }
                  plugin = [plugin];
              }
      
              for (i = 0, l = plugin.length; i < l;i++) {
                  p = plugin[i];
                  name = p.NAME || p.fn.NAME;
                  hostClass._PLUG[name] = p;
              }
          }
      };
  
      /**
       * Unregisters any class level plugins which have been registered by the host class, or any
       * other class in the hierarchy.
       *
       * @method unplug
       * @static
       *
       * @param {Function} hostClass The host class from which to unregister the plugins
       * @param {Function | Array} plugin The plugin class, or an array of plugin classes
       * @for Plugin.Host
       */
      PluginHost.unplug = function(hostClass, plugin) {
          var p, i, l, name;
      
          if (hostClass !== Y.Base) {
              hostClass._UNPLUG = hostClass._UNPLUG || {};
      
              if (!L.isArray(plugin)) {
                  plugin = [plugin];
              }
      
              for (i = 0, l = plugin.length; i < l; i++) {
                  p = plugin[i];
                  name = p.NAME;
                  if (!hostClass._PLUG[name]) {
                      hostClass._UNPLUG[name] = p;
                  } else {
                      delete hostClass._PLUG[name];
                  }
              }
          }
      };
  
  
  }, '@VERSION@' ,{requires:['pluginhost-base']});
  YUI.add('event-delegate', function(Y) {
  
  /**
   * Adds event delegation support to the library.
   *
   * @module event
   * @submodule event-delegate
   */
  
  var toArray          = Y.Array,
      YLang            = Y.Lang,
      isString         = YLang.isString,
      isObject         = YLang.isObject,
      isArray          = YLang.isArray,
      selectorTest     = Y.Selector.test,
      detachCategories = Y.Env.evt.handles;
  
  /**
   * <p>Sets up event delegation on a container element.  The delegated event
   * will use a supplied selector or filtering function to test if the event
   * references at least one node that should trigger the subscription
   * callback.</p>
   *
   * <p>Selector string filters will trigger the callback if the event originated
   * from a node that matches it or is contained in a node that matches it.
   * Function filters are called for each Node up the parent axis to the
   * subscribing container node, and receive at each level the Node and the event
   * object.  The function should return true (or a truthy value) if that Node
   * should trigger the subscription callback.  Note, it is possible for filters
   * to match multiple Nodes for a single event.  In this case, the delegate
   * callback will be executed for each matching Node.</p>
   *
   * <p>For each matching Node, the callback will be executed with its 'this'
   * object set to the Node matched by the filter (unless a specific context was
   * provided during subscription), and the provided event's
   * <code>currentTarget</code> will also be set to the matching Node.  The
   * containing Node from which the subscription was originally made can be
   * referenced as <code>e.container</code>.
   *
   * @method delegate
   * @param type {String} the event type to delegate
   * @param fn {Function} the callback function to execute.  This function
   *              will be provided the event object for the delegated event.
   * @param el {String|node} the element that is the delegation container
   * @param filter {string|Function} a selector that must match the target of the
   *              event or a function to test target and its parents for a match
   * @param context optional argument that specifies what 'this' refers to.
   * @param args* 0..n additional arguments to pass on to the callback function.
   *              These arguments will be added after the event object.
   * @return {EventHandle} the detach handle
   * @static
   * @for Event
   */
  function delegate(type, fn, el, filter) {
      var args     = toArray(arguments, 0, true),
          query    = isString(el) ? el : null,
          typeBits, synth, container, categories, cat, i, len, handles, handle;
  
      // Support Y.delegate({ click: fnA, key: fnB }, el, filter, ...);
      // and Y.delegate(['click', 'key'], fn, el, filter, ...);
      if (isObject(type)) {
          handles = [];
  
          if (isArray(type)) {
              for (i = 0, len = type.length; i < len; ++i) {
                  args[0] = type[i];
                  handles.push(Y.delegate.apply(Y, args));
              }
          } else {
              // Y.delegate({'click', fn}, el, filter) =>
              // Y.delegate('click', fn, el, filter)
              args.unshift(null); // one arg becomes two; need to make space
  
              for (i in type) {
                  if (type.hasOwnProperty(i)) {
                      args[0] = i;
                      args[1] = type[i];
                      handles.push(Y.delegate.apply(Y, args));
                  }
              }
          }
  
          return new Y.EventHandle(handles);
      }
  
      typeBits = type.split(/\|/);
  
      if (typeBits.length > 1) {
          cat  = typeBits.shift();
          args[0] = type = typeBits.shift();
      }
  
      synth = Y.Node.DOM_EVENTS[type];
  
      if (isObject(synth) && synth.delegate) {
          handle = synth.delegate.apply(synth, arguments);
      }
  
      if (!handle) {
          if (!type || !fn || !el || !filter) {
              return;
          }
  
          container = (query) ? Y.Selector.query(query, null, true) : el;
  
          if (!container && isString(el)) {
              handle = Y.on('available', function () {
                  Y.mix(handle, Y.delegate.apply(Y, args), true);
              }, el);
          }
  
          if (!handle && container) {
              args.splice(2, 2, container); // remove the filter
  
              handle = Y.Event._attach(args, { facade: false });
              handle.sub.filter  = filter;
              handle.sub._notify = delegate.notifySub;
          }
      }
  
      if (handle && cat) {
          categories = detachCategories[cat]  || (detachCategories[cat] = {});
          categories = categories[type] || (categories[type] = []);
          categories.push(handle);
      }
  
      return handle;
  }
  
  /**
  Overrides the <code>_notify</code> method on the normal DOM subscription to
  inject the filtering logic and only proceed in the case of a match.
  
  This method is hosted as a private property of the `delegate` method
  (e.g. `Y.delegate.notifySub`)
  
  @method notifySub
  @param thisObj {Object} default 'this' object for the callback
  @param args {Array} arguments passed to the event's <code>fire()</code>
  @param ce {CustomEvent} the custom event managing the DOM subscriptions for
               the subscribed event on the subscribing node.
  @return {Boolean} false if the event was stopped
  @private
  @static
  @since 3.2.0
  **/
  delegate.notifySub = function (thisObj, args, ce) {
      // Preserve args for other subscribers
      args = args.slice();
      if (this.args) {
          args.push.apply(args, this.args);
      }
  
      // Only notify subs if the event occurred on a targeted element
      var currentTarget = delegate._applyFilter(this.filter, args, ce),
          //container     = e.currentTarget,
          e, i, len, ret;
  
      if (currentTarget) {
          // Support multiple matches up the the container subtree
          currentTarget = toArray(currentTarget);
  
          // The second arg is the currentTarget, but we'll be reusing this
          // facade, replacing the currentTarget for each use, so it doesn't
          // matter what element we seed it with.
          e = args[0] = new Y.DOMEventFacade(args[0], ce.el, ce);
  
          e.container = Y.one(ce.el);
  
          for (i = 0, len = currentTarget.length; i < len && !e.stopped; ++i) {
              e.currentTarget = Y.one(currentTarget[i]);
  
              ret = this.fn.apply(this.context || e.currentTarget, args);
  
              if (ret === false) { // stop further notifications
                  break;
              }
          }
  
          return ret;
      }
  };
  
  /**
  Compiles a selector string into a filter function to identify whether
  Nodes along the parent axis of an event's target should trigger event
  notification.
  
  This function is memoized, so previously compiled filter functions are
  returned if the same selector string is provided.
  
  This function may be useful when defining synthetic events for delegate
  handling.
  
  Hosted as a property of the `delegate` method (e.g. `Y.delegate.compileFilter`).
  
  @method compileFilter
  @param selector {String} the selector string to base the filtration on
  @return {Function}
  @since 3.2.0
  @static
  **/
  delegate.compileFilter = Y.cached(function (selector) {
      return function (target, e) {
          return selectorTest(target._node, selector,
              (e.currentTarget === e.target) ? null : e.currentTarget._node);
      };
  });
  
  /**
  Walks up the parent axis of an event's target, and tests each element
  against a supplied filter function.  If any Nodes, including the container,
  satisfy the filter, the delegated callback will be triggered for each.
  
  Hosted as a protected property of the `delegate` method (e.g.
  `Y.delegate._applyFilter`).
  
  @method _applyFilter
  @param filter {Function} boolean function to test for inclusion in event
                   notification
  @param args {Array} the arguments that would be passed to subscribers
  @param ce   {CustomEvent} the DOM event wrapper
  @return {Node|Node[]|undefined} The Node or Nodes that satisfy the filter
  @protected
  **/
  delegate._applyFilter = function (filter, args, ce) {
      var e         = args[0],
          container = ce.el, // facadeless events in IE, have no e.currentTarget
          target    = e.target || e.srcElement,
          match     = [],
          isContainer = false;
  
      // Resolve text nodes to their containing element
      if (target.nodeType === 3) {
          target = target.parentNode;
      }
  
      // passing target as the first arg rather than leaving well enough alone
      // making 'this' in the filter function refer to the target.  This is to
      // support bound filter functions.
      args.unshift(target);
  
      if (isString(filter)) {
          while (target) {
              isContainer = (target === container);
              if (selectorTest(target, filter, (isContainer ? null: container))) {
                  match.push(target);
              }
  
              if (isContainer) {
                  break;
              }
  
              target = target.parentNode;
          }
      } else {
          // filter functions are implementer code and should receive wrappers
          args[0] = Y.one(target);
          args[1] = new Y.DOMEventFacade(e, container, ce);
  
          while (target) {
              // filter(target, e, extra args...) - this === target
              if (filter.apply(args[0], args)) {
                  match.push(target);
              }
  
              if (target === container) {
                  break;
              }
  
              target = target.parentNode;
              args[0] = Y.one(target);
          }
          args[1] = e; // restore the raw DOM event
      }
  
      if (match.length <= 1) {
          match = match[0]; // single match or undefined
      }
  
      // remove the target
      args.shift();
  
      return match;
  };
  
  /**
   * Sets up event delegation on a container element.  The delegated event
   * will use a supplied filter to test if the callback should be executed.
   * This filter can be either a selector string or a function that returns
   * a Node to use as the currentTarget for the event.
   *
   * The event object for the delegated event is supplied to the callback
   * function.  It is modified slightly in order to support all properties
   * that may be needed for event delegation.  'currentTarget' is set to
   * the element that matched the selector string filter or the Node returned
   * from the filter function.  'container' is set to the element that the
   * listener is delegated from (this normally would be the 'currentTarget').
   *
   * Filter functions will be called with the arguments that would be passed to
   * the callback function, including the event object as the first parameter.
   * The function should return false (or a falsey value) if the success criteria
   * aren't met, and the Node to use as the event's currentTarget and 'this'
   * object if they are.
   *
   * @method delegate
   * @param type {string} the event type to delegate
   * @param fn {function} the callback function to execute.  This function
   * will be provided the event object for the delegated event.
   * @param el {string|node} the element that is the delegation container
   * @param filter {string|function} a selector that must match the target of the
   * event or a function that returns a Node or false.
   * @param context optional argument that specifies what 'this' refers to.
   * @param args* 0..n additional arguments to pass on to the callback function.
   * These arguments will be added after the event object.
   * @return {EventHandle} the detach handle
   * @for YUI
   */
  Y.delegate = Y.Event.delegate = delegate;
  
  
  }, '@VERSION@' ,{requires:['node-base']});
  YUI.add('node-event-delegate', function(Y) {
  
  /**
   * Functionality to make the node a delegated event container
   * @module node
   * @submodule node-event-delegate
   */
  
  /**
   * <p>Sets up a delegation listener for an event occurring inside the Node.
   * The delegated event will be verified against a supplied selector or
   * filtering function to test if the event references at least one node that
   * should trigger the subscription callback.</p>
   *
   * <p>Selector string filters will trigger the callback if the event originated
   * from a node that matches it or is contained in a node that matches it.
   * Function filters are called for each Node up the parent axis to the
   * subscribing container node, and receive at each level the Node and the event
   * object.  The function should return true (or a truthy value) if that Node
   * should trigger the subscription callback.  Note, it is possible for filters
   * to match multiple Nodes for a single event.  In this case, the delegate
   * callback will be executed for each matching Node.</p>
   *
   * <p>For each matching Node, the callback will be executed with its 'this'
   * object set to the Node matched by the filter (unless a specific context was
   * provided during subscription), and the provided event's
   * <code>currentTarget</code> will also be set to the matching Node.  The
   * containing Node from which the subscription was originally made can be
   * referenced as <code>e.container</code>.
   *
   * @method delegate
   * @param type {String} the event type to delegate
   * @param fn {Function} the callback function to execute.  This function
   *              will be provided the event object for the delegated event.
   * @param spec {String|Function} a selector that must match the target of the
   *              event or a function to test target and its parents for a match
   * @param context {Object} optional argument that specifies what 'this' refers to.
   * @param args* {any} 0..n additional arguments to pass on to the callback function.
   *              These arguments will be added after the event object.
   * @return {EventHandle} the detach handle
   * @for Node
   */
  Y.Node.prototype.delegate = function(type) {
  
      var args = Y.Array(arguments, 0, true),
          index = (Y.Lang.isObject(type) && !Y.Lang.isArray(type)) ? 1 : 2;
  
      args.splice(index, 0, this._node);
  
      return Y.delegate.apply(Y, args);
  };
  
  
  }, '@VERSION@' ,{requires:['node-base', 'event-delegate']});
  YUI.add('node-pluginhost', function(Y) {
  
  /**
   * @module node
   * @submodule node-pluginhost
   */
  
  /**
   * Registers plugins to be instantiated at the class level (plugins
   * which should be plugged into every instance of Node by default).
   *
   * @method plug
   * @static
   * @for Node
   * @param {Function | Array} plugin Either the plugin class, an array of plugin classes or an array of objects (with fn and cfg properties defined)
   * @param {Object} config (Optional) If plugin is the plugin class, the configuration for the plugin
   */
  Y.Node.plug = function() {
      var args = Y.Array(arguments);
      args.unshift(Y.Node);
      Y.Plugin.Host.plug.apply(Y.Base, args);
      return Y.Node;
  };
  
  /**
   * Unregisters any class level plugins which have been registered by the Node
   *
   * @method unplug
   * @static
   *
   * @param {Function | Array} plugin The plugin class, or an array of plugin classes
   */
  Y.Node.unplug = function() {
      var args = Y.Array(arguments);
      args.unshift(Y.Node);
      Y.Plugin.Host.unplug.apply(Y.Base, args);
      return Y.Node;
  };
  
  Y.mix(Y.Node, Y.Plugin.Host, false, null, 1);
  
  // allow batching of plug/unplug via NodeList
  // doesn't use NodeList.importMethod because we need real Nodes (not tmpNode)
  /**
   * Adds a plugin to each node in the NodeList.
   * This will instantiate the plugin and attach it to the configured namespace on each node
   * @method plug
   * @for NodeList
   * @param P {Function | Object |Array} Accepts the plugin class, or an 
   * object with a "fn" property specifying the plugin class and 
   * a "cfg" property specifying the configuration for the Plugin.
   * <p>
   * Additionally an Array can also be passed in, with the above function or 
   * object values, allowing the user to add multiple plugins in a single call.
   * </p>
   * @param config (Optional) If the first argument is the plugin class, the second argument
   * can be the configuration for the plugin.
   * @chainable
   */
  Y.NodeList.prototype.plug = function() {
      var args = arguments;
      Y.NodeList.each(this, function(node) {
          Y.Node.prototype.plug.apply(Y.one(node), args);
      });
      return this;
  };
  
  /**
   * Removes a plugin from all nodes in the NodeList. This will destroy the 
   * plugin instance and delete the namespace each node. 
   * @method unplug
   * @for NodeList
   * @param {String | Function} plugin The namespace of the plugin, or the plugin class with the static NS namespace property defined. If not provided,
   * all registered plugins are unplugged.
   * @chainable
   */
  Y.NodeList.prototype.unplug = function() {
      var args = arguments;
      Y.NodeList.each(this, function(node) {
          Y.Node.prototype.unplug.apply(Y.one(node), args);
      });
      return this;
  };
  
  
  }, '@VERSION@' ,{requires:['node-base', 'pluginhost']});
  YUI.add('node-screen', function(Y) {
  
  /**
   * Extended Node interface for managing regions and screen positioning.
   * Adds support for positioning elements and normalizes window size and scroll detection. 
   * @module node
   * @submodule node-screen
   */
  
  // these are all "safe" returns, no wrapping required
  Y.each([
      /**
       * Returns the inner width of the viewport (exludes scrollbar). 
       * @config winWidth
       * @for Node
       * @type {Int}
       */
      'winWidth',
  
      /**
       * Returns the inner height of the viewport (exludes scrollbar). 
       * @config winHeight
       * @type {Int}
       */
      'winHeight',
  
      /**
       * Document width 
       * @config docWidth
       * @type {Int}
       */
      'docWidth',
  
      /**
       * Document height 
       * @config docHeight
       * @type {Int}
       */
      'docHeight',
  
      /**
       * Pixel distance the page has been scrolled horizontally 
       * @config docScrollX
       * @type {Int}
       */
      'docScrollX',
  
      /**
       * Pixel distance the page has been scrolled vertically 
       * @config docScrollY
       * @type {Int}
       */
      'docScrollY'
      ],
      function(name) {
          Y.Node.ATTRS[name] = {
              getter: function() {
                  var args = Array.prototype.slice.call(arguments);
                  args.unshift(Y.Node.getDOMNode(this));
  
                  return Y.DOM[name].apply(this, args);
              }
          };
      }
  );
  
  Y.Node.ATTRS.scrollLeft = {
      getter: function() {
          var node = Y.Node.getDOMNode(this);
          return ('scrollLeft' in node) ? node.scrollLeft : Y.DOM.docScrollX(node);
      },
  
      setter: function(val) {
          var node = Y.Node.getDOMNode(this);
          if (node) {
              if ('scrollLeft' in node) {
                  node.scrollLeft = val;
              } else if (node.document || node.nodeType === 9) {
                  Y.DOM._getWin(node).scrollTo(val, Y.DOM.docScrollY(node)); // scroll window if win or doc
              }
          } else {
          }
      }
  };
  
  Y.Node.ATTRS.scrollTop = {
      getter: function() {
          var node = Y.Node.getDOMNode(this);
          return ('scrollTop' in node) ? node.scrollTop : Y.DOM.docScrollY(node);
      },
  
      setter: function(val) {
          var node = Y.Node.getDOMNode(this);
          if (node) {
              if ('scrollTop' in node) {
                  node.scrollTop = val;
              } else if (node.document || node.nodeType === 9) {
                  Y.DOM._getWin(node).scrollTo(Y.DOM.docScrollX(node), val); // scroll window if win or doc
              }
          } else {
          }
      }
  };
  
  Y.Node.importMethod(Y.DOM, [
  /**
   * Gets the current position of the node in page coordinates. 
   * @method getXY
   * @for Node
   * @return {Array} The XY position of the node
  */
      'getXY',
  
  /**
   * Set the position of the node in page coordinates, regardless of how the node is positioned.
   * @method setXY
   * @param {Array} xy Contains X & Y values for new position (coordinates are page-based)
   * @chainable
   */
      'setXY',
  
  /**
   * Gets the current position of the node in page coordinates. 
   * @method getX
   * @return {Int} The X position of the node
  */
      'getX',
  
  /**
   * Set the position of the node in page coordinates, regardless of how the node is positioned.
   * @method setX
   * @param {Int} x X value for new position (coordinates are page-based)
   * @chainable
   */
      'setX',
  
  /**
   * Gets the current position of the node in page coordinates. 
   * @method getY
   * @return {Int} The Y position of the node
  */
      'getY',
  
  /**
   * Set the position of the node in page coordinates, regardless of how the node is positioned.
   * @method setY
   * @param {Int} y Y value for new position (coordinates are page-based)
   * @chainable
   */
      'setY',
  
  /**
   * Swaps the XY position of this node with another node. 
   * @method swapXY
   * @param {Node | HTMLElement} otherNode The node to swap with.
   * @chainable
   */
      'swapXY'
  ]);
  
  /**
   * @module node
   * @submodule node-screen
   */
  
  /**
   * Returns a region object for the node
   * @config region
   * @for Node
   * @type Node
   */
  Y.Node.ATTRS.region = {
      getter: function() {
          var node = this.getDOMNode(),
              region;
  
          if (node && !node.tagName) {
              if (node.nodeType === 9) { // document
                  node = node.documentElement;
              }
          }
          if (Y.DOM.isWindow(node)) {
              region = Y.DOM.viewportRegion(node);
          } else {
              region = Y.DOM.region(node);
          }
          return region;
      }
  };
  
  /**
   * Returns a region object for the node's viewport
   * @config viewportRegion
   * @type Node
   */
  Y.Node.ATTRS.viewportRegion = {
      getter: function() {
          return Y.DOM.viewportRegion(Y.Node.getDOMNode(this));
      }
  };
  
  Y.Node.importMethod(Y.DOM, 'inViewportRegion');
  
  // these need special treatment to extract 2nd node arg
  /**
   * Compares the intersection of the node with another node or region
   * @method intersect
   * @for Node
   * @param {Node|Object} node2 The node or region to compare with.
   * @param {Object} altRegion An alternate region to use (rather than this node's).
   * @return {Object} An object representing the intersection of the regions.
   */
  Y.Node.prototype.intersect = function(node2, altRegion) {
      var node1 = Y.Node.getDOMNode(this);
      if (Y.instanceOf(node2, Y.Node)) { // might be a region object
          node2 = Y.Node.getDOMNode(node2);
      }
      return Y.DOM.intersect(node1, node2, altRegion);
  };
  
  /**
   * Determines whether or not the node is within the giving region.
   * @method inRegion
   * @param {Node|Object} node2 The node or region to compare with.
   * @param {Boolean} all Whether or not all of the node must be in the region.
   * @param {Object} altRegion An alternate region to use (rather than this node's).
   * @return {Object} An object representing the intersection of the regions.
   */
  Y.Node.prototype.inRegion = function(node2, all, altRegion) {
      var node1 = Y.Node.getDOMNode(this);
      if (Y.instanceOf(node2, Y.Node)) { // might be a region object
          node2 = Y.Node.getDOMNode(node2);
      }
      return Y.DOM.inRegion(node1, node2, all, altRegion);
  };
  
  
  }, '@VERSION@' ,{requires:['node-base', 'dom-screen']});
  YUI.add('node-style', function(Y) {
  
  (function(Y) {
  /**
   * Extended Node interface for managing node styles.
   * @module node
   * @submodule node-style
   */
  
  Y.mix(Y.Node.prototype, {
      /**
       * Sets a style property of the node.
       * Use camelCase (e.g. 'backgroundColor') for multi-word properties.
       * @method setStyle
       * @param {String} attr The style attribute to set. 
       * @param {String|Number} val The value. 
       * @chainable
       */
      setStyle: function(attr, val) {
          Y.DOM.setStyle(this._node, attr, val);
          return this;
      },
  
      /**
       * Sets multiple style properties on the node.
       * Use camelCase (e.g. 'backgroundColor') for multi-word properties.
       * @method setStyles
       * @param {Object} hash An object literal of property:value pairs. 
       * @chainable
       */
      setStyles: function(hash) {
          Y.DOM.setStyles(this._node, hash);
          return this;
      },
  
      /**
       * Returns the style's current value.
       * Use camelCase (e.g. 'backgroundColor') for multi-word properties.
       * @method getStyle
       * @for Node
       * @param {String} attr The style attribute to retrieve. 
       * @return {String} The current value of the style property for the element.
       */
  
       getStyle: function(attr) {
          return Y.DOM.getStyle(this._node, attr);
       },
  
      /**
       * Returns the computed value for the given style property.
       * Use camelCase (e.g. 'backgroundColor') for multi-word properties.
       * @method getComputedStyle
       * @param {String} attr The style attribute to retrieve. 
       * @return {String} The computed value of the style property for the element.
       */
       getComputedStyle: function(attr) {
          return Y.DOM.getComputedStyle(this._node, attr);
       }
  });
  
  /**
   * Returns an array of values for each node.
   * Use camelCase (e.g. 'backgroundColor') for multi-word properties.
   * @method getStyle
   * @for NodeList
   * @see Node.getStyle
   * @param {String} attr The style attribute to retrieve. 
   * @return {Array} The current values of the style property for the element.
   */
  
  /**
   * Returns an array of the computed value for each node.
   * Use camelCase (e.g. 'backgroundColor') for multi-word properties.
   * @method getComputedStyle
   * @see Node.getComputedStyle
   * @param {String} attr The style attribute to retrieve. 
   * @return {Array} The computed values for each node.
   */
  
  /**
   * Sets a style property on each node.
   * Use camelCase (e.g. 'backgroundColor') for multi-word properties.
   * @method setStyle
   * @see Node.setStyle
   * @param {String} attr The style attribute to set. 
   * @param {String|Number} val The value. 
   * @chainable
   */
  
  /**
   * Sets multiple style properties on each node.
   * Use camelCase (e.g. 'backgroundColor') for multi-word properties.
   * @method setStyles
   * @see Node.setStyles
   * @param {Object} hash An object literal of property:value pairs. 
   * @chainable
   */
  
  // These are broken out to handle undefined return (avoid false positive for
  // chainable)
  
  Y.NodeList.importMethod(Y.Node.prototype, ['getStyle', 'getComputedStyle', 'setStyle', 'setStyles']);
  })(Y);
  
  
  }, '@VERSION@' ,{requires:['dom-style', 'node-base']});
  YUI.add('querystring-stringify-simple', function(Y) {
  
  /*global Y */
  /**
   * <p>Provides Y.QueryString.stringify method for converting objects to Query Strings.
   * This is a subset implementation of the full querystring-stringify.</p>
   * <p>This module provides the bare minimum functionality (encoding a hash of simple values),
   * without the additional support for nested data structures.  Every key-value pair is
   * encoded by encodeURIComponent.</p>
   * <p>This module provides a minimalistic way for io to handle  single-level objects
   * as transaction data.</p>
   *
   * @module querystring
   * @submodule querystring-stringify-simple
   * @for QueryString
   * @static
   */
  
  var QueryString = Y.namespace("QueryString"),
      EUC = encodeURIComponent;
  
  /**
   * <p>Converts a simple object to a Query String representation.</p>
   * <p>Nested objects, Arrays, and so on, are not supported.</p>
   *
   * @method stringify
   * @for QueryString
   * @public
   * @submodule querystring-stringify-simple
   * @param obj {Object} A single-level object to convert to a querystring.
   * @param cfg {Object} (optional) Configuration object.  In the simple
   *                                module, only the arrayKey setting is
   *                                supported.  When set to true, the key of an
   *                                array will have the '[]' notation appended
   *                                to the key;.
   * @static
   */
  QueryString.stringify = function (obj, c) {
      var qs = [],
          // Default behavior is false; standard key notation.
          s = c && c.arrayKey ? true : false,
          key, i, l;
  
      for (key in obj) {
          if (obj.hasOwnProperty(key)) {
              if (Y.Lang.isArray(obj[key])) {
                  for (i = 0, l = obj[key].length; i < l; i++) {
                      qs.push(EUC(s ? key + '[]' : key) + '=' + EUC(obj[key][i]));
                  }
              }
              else {
                  qs.push(EUC(key) + '=' + EUC(obj[key]));
              }
          }
      }
  
      return qs.join('&');
  };
  
  
  }, '@VERSION@' ,{requires:['yui-base']});
  YUI.add('io-base', function(Y) {
  
  /**
  Base IO functionality. Provides basic XHR transport support.
  
  @module io
  @submodule io-base
  @for IO
  **/
  
  var // List of events that comprise the IO event lifecycle.
      EVENTS = ['start', 'complete', 'end', 'success', 'failure', 'progress'],
  
      // Whitelist of used XHR response object properties.
      XHR_PROPS = ['status', 'statusText', 'responseText', 'responseXML'],
  
      win = Y.config.win,
      uid = 0;
  
  /**
  The IO class is a utility that brokers HTTP requests through a simplified
  interface.  Specifically, it allows JavaScript to make HTTP requests to
  a resource without a page reload.  The underlying transport for making
  same-domain requests is the XMLHttpRequest object.  IO can also use
  Flash, if specified as a transport, for cross-domain requests.
  
  @class IO
  @constructor
  @param {Object} config Object of EventTarget's publish method configurations
                      used to configure IO's events.
  **/
  function IO (config) {
      var io = this;
  
      io._uid = 'io:' + uid++;
      io._init(config);
      Y.io._map[io._uid] = io;
  }
  
  IO.prototype = {
      //--------------------------------------
      //  Properties
      //--------------------------------------
  
     /**
      * A counter that increments for each transaction.
      *
      * @property _id
      * @private
      * @type {Number}
      */
      _id: 0,
  
     /**
      * Object of IO HTTP headers sent with each transaction.
      *
      * @property _headers
      * @private
      * @type {Object}
      */
      _headers: {
          'X-Requested-With' : 'XMLHttpRequest'
      },
  
     /**
      * Object that stores timeout values for any transaction with a defined
      * "timeout" configuration property.
      *
      * @property _timeout
      * @private
      * @type {Object}
      */
      _timeout: {},
  
      //--------------------------------------
      //  Methods
      //--------------------------------------
  
      _init: function(config) {
          var io = this, i, len;
  
          io.cfg = config || {};
  
          Y.augment(io, Y.EventTarget);
          for (i = 0, len = EVENTS.length; i < len; ++i) {
              // Publish IO global events with configurations, if any.
              // IO global events are set to broadcast by default.
              // These events use the "io:" namespace.
              io.publish('io:' + EVENTS[i], Y.merge({ broadcast: 1 }, config));
              // Publish IO transaction events with configurations, if
              // any.  These events use the "io-trn:" namespace.
              io.publish('io-trn:' + EVENTS[i], config);
          }
      },
  
     /**
      * Method that creates a unique transaction object for each request.
      *
      * @method _create
      * @private
      * @param {Object} cfg Configuration object subset to determine if
      *                 the transaction is an XDR or file upload,
      *                 requiring an alternate transport.
      * @param {Number} id Transaction id
      * @return {Object} The transaction object
      */
      _create: function(config, id) {
          var io = this,
              transaction = {
                  id : Y.Lang.isNumber(id) ? id : io._id++,
                  uid: io._uid
              },
              alt = config.xdr ? config.xdr.use : null,
              form = config.form && config.form.upload ? 'iframe' : null,
              use;
  
          if (alt === 'native') {
              // Non-IE  can use XHR level 2 and not rely on an
              // external transport.
              alt = Y.UA.ie ? 'xdr' : null;
          }
  
          use = alt || form;
          transaction = use ? Y.merge(Y.IO.customTransport(use), transaction) :
                              Y.merge(Y.IO.defaultTransport(), transaction);
  
          if (transaction.notify) {
              config.notify = function (e, t, c) { io.notify(e, t, c); };
          }
  
          if (!use) {
              if (win && win.FormData && config.data instanceof FormData) {
                  transaction.c.upload.onprogress = function (e) {
                      io.progress(transaction, e, config);
                  };
                  transaction.c.onload = function (e) {
                      io.load(transaction, e, config);
                  };
                  transaction.c.onerror = function (e) {
                      io.error(transaction, e, config);
                  };
                  transaction.upload = true;
              }
          }
  
          return transaction;
      },
  
      _destroy: function(transaction) {
          if (win && !transaction.notify && !transaction.xdr) {
              if (XHR && !transaction.upload) {
                  transaction.c.onreadystatechange = null;
              } else if (transaction.upload) {
                  transaction.c.upload.onprogress = null;
                  transaction.c.onload = null;
                  transaction.c.onerror = null;
              } else if (Y.UA.ie && !transaction.e) {
                  // IE, when using XMLHttpRequest as an ActiveX Object, will throw
                  // a "Type Mismatch" error if the event handler is set to "null".
                  transaction.c.abort();
              }
          }
  
          transaction = transaction.c = null;
      },
  
     /**
      * Method for creating and firing events.
      *
      * @method _evt
      * @private
      * @param {String} eventName Event to be published.
      * @param {Object} transaction Transaction object.
      * @param {Object} config Configuration data subset for event subscription.
      */
      _evt: function(eventName, transaction, config) {
          var io          = this, params,
              args        = config['arguments'],
              emitFacade  = io.cfg.emitFacade,
              globalEvent = "io:" + eventName,
              trnEvent    = "io-trn:" + eventName;
  
          // Workaround for #2532107
          this.detach(trnEvent);
  
          if (transaction.e) {
              transaction.c = { status: 0, statusText: transaction.e };
          }
  
          // Fire event with parameters or an Event Facade.
          params = [ emitFacade ?
              {
                  id: transaction.id,
                  data: transaction.c,
                  cfg: config,
                  'arguments': args
              } :
              transaction.id
          ];
  
          if (!emitFacade) {
              if (eventName === EVENTS[0] || eventName === EVENTS[2]) {
                  if (args) {
                      params.push(args);
                  }
              } else {
                  if (transaction.evt) {
                      params.push(transaction.evt);
                  } else {
                      params.push(transaction.c);
                  }
                  if (args) {
                      params.push(args);
                  }
              }
          }
  
          params.unshift(globalEvent);
          // Fire global events.
          io.fire.apply(io, params);
          // Fire transaction events, if receivers are defined.
          if (config.on) {
              params[0] = trnEvent;
              io.once(trnEvent, config.on[eventName], config.context || Y);
              io.fire.apply(io, params);
          }
      },
  
     /**
      * Fires event "io:start" and creates, fires a transaction-specific
      * start event, if `config.on.start` is defined.
      *
      * @method start
      * @param {Object} transaction Transaction object.
      * @param {Object} config Configuration object for the transaction.
      */
      start: function(transaction, config) {
         /**
          * Signals the start of an IO request.
          * @event io:start
          */
          this._evt(EVENTS[0], transaction, config);
      },
  
     /**
      * Fires event "io:complete" and creates, fires a
      * transaction-specific "complete" event, if config.on.complete is
      * defined.
      *
      * @method complete
      * @param {Object} transaction Transaction object.
      * @param {Object} config Configuration object for the transaction.
      */
      complete: function(transaction, config) {
         /**
          * Signals the completion of the request-response phase of a
          * transaction. Response status and data are accessible, if
          * available, in this event.
          * @event io:complete
          */
          this._evt(EVENTS[1], transaction, config);
      },
  
     /**
      * Fires event "io:end" and creates, fires a transaction-specific "end"
      * event, if config.on.end is defined.
      *
      * @method end
      * @param {Object} transaction Transaction object.
      * @param {Object} config Configuration object for the transaction.
      */
      end: function(transaction, config) {
         /**
          * Signals the end of the transaction lifecycle.
          * @event io:end
          */
          this._evt(EVENTS[2], transaction, config);
          this._destroy(transaction);
      },
  
     /**
      * Fires event "io:success" and creates, fires a transaction-specific
      * "success" event, if config.on.success is defined.
      *
      * @method success
      * @param {Object} transaction Transaction object.
      * @param {Object} config Configuration object for the transaction.
      */
      success: function(transaction, config) {
         /**
          * Signals an HTTP response with status in the 2xx range.
          * Fires after io:complete.
          * @event io:success
          */
          this._evt(EVENTS[3], transaction, config);
          this.end(transaction, config);
      },
  
     /**
      * Fires event "io:failure" and creates, fires a transaction-specific
      * "failure" event, if config.on.failure is defined.
      *
      * @method failure
      * @param {Object} transaction Transaction object.
      * @param {Object} config Configuration object for the transaction.
      */
      failure: function(transaction, config) {
         /**
          * Signals an HTTP response with status outside of the 2xx range.
          * Fires after io:complete.
          * @event io:failure
          */
          this._evt(EVENTS[4], transaction, config);
          this.end(transaction, config);
      },
  
     /**
      * Fires event "io:progress" and creates, fires a transaction-specific
      * "progress" event -- for XMLHttpRequest file upload -- if
      * config.on.progress is defined.
      *
      * @method progress
      * @param {Object} transaction Transaction object.
      * @param {Object} progress event.
      * @param {Object} config Configuration object for the transaction.
      */
      progress: function(transaction, e, config) {
         /**
          * Signals the interactive state during a file upload transaction.
          * This event fires after io:start and before io:complete.
          * @event io:progress
          */
          transaction.evt = e;
          this._evt(EVENTS[5], transaction, config);
      },
  
     /**
      * Fires event "io:complete" and creates, fires a transaction-specific
      * "complete" event -- for XMLHttpRequest file upload -- if
      * config.on.complete is defined.
      *
      * @method load
      * @param {Object} transaction Transaction object.
      * @param {Object} load event.
      * @param {Object} config Configuration object for the transaction.
      */
      load: function (transaction, e, config) {
          transaction.evt = e.target;
          this._evt(EVENTS[1], transaction, config);
      },
  
     /**
      * Fires event "io:failure" and creates, fires a transaction-specific
      * "failure" event -- for XMLHttpRequest file upload -- if
      * config.on.failure is defined.
      *
      * @method error
      * @param {Object} transaction Transaction object.
      * @param {Object} error event.
      * @param {Object} config Configuration object for the transaction.
      */
      error: function (transaction, e, config) {
          transaction.evt = e;
          this._evt(EVENTS[4], transaction, config);
      },
  
     /**
      * Retry an XDR transaction, using the Flash tranport, if the native
      * transport fails.
      *
      * @method _retry
      * @private
      * @param {Object} transaction Transaction object.
      * @param {String} uri Qualified path to transaction resource.
      * @param {Object} config Configuration object for the transaction.
      */
      _retry: function(transaction, uri, config) {
          this._destroy(transaction);
          config.xdr.use = 'flash';
          return this.send(uri, config, transaction.id);
      },
  
     /**
      * Method that concatenates string data for HTTP GET transactions.
      *
      * @method _concat
      * @private
      * @param {String} uri URI or root data.
      * @param {String} data Data to be concatenated onto URI.
      * @return {String}
      */
      _concat: function(uri, data) {
          uri += (uri.indexOf('?') === -1 ? '?' : '&') + data;
          return uri;
      },
  
     /**
      * Stores default client headers for all transactions. If a label is
      * passed with no value argument, the header will be deleted.
      *
      * @method setHeader
      * @param {String} name HTTP header
      * @param {String} value HTTP header value
      */
      setHeader: function(name, value) {
          if (value) {
              this._headers[name] = value;
          } else {
              delete this._headers[name];
          }
      },
  
     /**
      * Method that sets all HTTP headers to be sent in a transaction.
      *
      * @method _setHeaders
      * @private
      * @param {Object} transaction - XHR instance for the specific transaction.
      * @param {Object} headers - HTTP headers for the specific transaction, as
      *                    defined in the configuration object passed to YUI.io().
      */
      _setHeaders: function(transaction, headers) {
          headers = Y.merge(this._headers, headers);
          Y.Object.each(headers, function(value, name) {
              if (value !== 'disable') {
                  transaction.setRequestHeader(name, headers[name]);
              }
          });
      },
  
     /**
      * Starts timeout count if the configuration object has a defined
      * timeout property.
      *
      * @method _startTimeout
      * @private
      * @param {Object} transaction Transaction object generated by _create().
      * @param {Object} timeout Timeout in milliseconds.
      */
      _startTimeout: function(transaction, timeout) {
          var io = this;
  
          io._timeout[transaction.id] = setTimeout(function() {
              io._abort(transaction, 'timeout');
          }, timeout);
      },
  
     /**
      * Clears the timeout interval started by _startTimeout().
      *
      * @method _clearTimeout
      * @private
      * @param {Number} id - Transaction id.
      */
      _clearTimeout: function(id) {
          clearTimeout(this._timeout[id]);
          delete this._timeout[id];
      },
  
     /**
      * Method that determines if a transaction response qualifies as success
      * or failure, based on the response HTTP status code, and fires the
      * appropriate success or failure events.
      *
      * @method _result
      * @private
      * @static
      * @param {Object} transaction Transaction object generated by _create().
      * @param {Object} config Configuration object passed to io().
      */
      _result: function(transaction, config) {
          var status;
          // Firefox will throw an exception if attempting to access
          // an XHR object's status property, after a request is aborted.
          try {
              status = transaction.c.status;
          } catch(e) {
              status = 0;
          }
  
          // IE reports HTTP 204 as HTTP 1223.
          if (status >= 200 && status < 300 || status === 304 || status === 1223) {
              this.success(transaction, config);
          } else {
              this.failure(transaction, config);
          }
      },
  
     /**
      * Event handler bound to onreadystatechange.
      *
      * @method _rS
      * @private
      * @param {Object} transaction Transaction object generated by _create().
      * @param {Object} config Configuration object passed to YUI.io().
      */
      _rS: function(transaction, config) {
          var io = this;
  
          if (transaction.c.readyState === 4) {
              if (config.timeout) {
                  io._clearTimeout(transaction.id);
              }
  
              // Yield in the event of request timeout or abort.
              setTimeout(function() {
                  io.complete(transaction, config);
                  io._result(transaction, config);
              }, 0);
          }
      },
  
     /**
      * Terminates a transaction due to an explicit abort or timeout.
      *
      * @method _abort
      * @private
      * @param {Object} transaction Transaction object generated by _create().
      * @param {String} type Identifies timed out or aborted transaction.
      */
      _abort: function(transaction, type) {
          if (transaction && transaction.c) {
              transaction.e = type;
              transaction.c.abort();
          }
      },
  
     /**
      * Requests a transaction. `send()` is implemented as `Y.io()`.  Each
      * transaction may include a configuration object.  Its properties are:
      *
      * <dl>
      *   <dt>method</dt>
      *     <dd>HTTP method verb (e.g., GET or POST). If this property is not
      *         not defined, the default value will be GET.</dd>
      *
      *   <dt>data</dt>
      *     <dd>This is the name-value string that will be sent as the
      *     transaction data. If the request is HTTP GET, the data become
      *     part of querystring. If HTTP POST, the data are sent in the
      *     message body.</dd>
      *
      *   <dt>xdr</dt>
      *     <dd>Defines the transport to be used for cross-domain requests.
      *     By setting this property, the transaction will use the specified
      *     transport instead of XMLHttpRequest. The properties of the
      *     transport object are:
      *     <dl>
      *       <dt>use</dt>
      *         <dd>The transport to be used: 'flash' or 'native'</dd>
      *       <dt>dataType</dt>
      *         <dd>Set the value to 'XML' if that is the expected response
      *         content type.</dd>
      *     </dl></dd>
      *
      *   <dt>form</dt>
      *     <dd>Form serialization configuration object.  Its properties are:
      *     <dl>
      *       <dt>id</dt>
      *         <dd>Node object or id of HTML form</dd>
      *       <dt>useDisabled</dt>
      *         <dd>`true` to also serialize disabled form field values
      *         (defaults to `false`)</dd>
      *     </dl></dd>
      *
      *   <dt>on</dt>
      *     <dd>Assigns transaction event subscriptions. Available events are:
      *     <dl>
      *       <dt>start</dt>
      *         <dd>Fires when a request is sent to a resource.</dd>
      *       <dt>complete</dt>
      *         <dd>Fires when the transaction is complete.</dd>
      *       <dt>success</dt>
      *         <dd>Fires when the HTTP response status is within the 2xx
      *         range.</dd>
      *       <dt>failure</dt>
      *         <dd>Fires when the HTTP response status is outside the 2xx
      *         range, if an exception occurs, if the transation is aborted,
      *         or if the transaction exceeds a configured `timeout`.</dd>
      *       <dt>end</dt>
      *         <dd>Fires at the conclusion of the transaction
      *            lifecycle, after `success` or `failure`.</dd>
      *     </dl>
      *
      *     <p>Callback functions for `start` and `end` receive the id of the
      *     transaction as a first argument. For `complete`, `success`, and
      *     `failure`, callbacks receive the id and the response object
      *     (usually the XMLHttpRequest instance).  If the `arguments`
      *     property was included in the configuration object passed to
      *     `Y.io()`, the configured data will be passed to all callbacks as
      *     the last argument.</p>
      *     </dd>
      *
      *   <dt>sync</dt>
      *     <dd>Pass `true` to make a same-domain transaction synchronous.
      *     <strong>CAVEAT</strong>: This will negatively impact the user
      *     experience. Have a <em>very</em> good reason if you intend to use
      *     this.</dd>
      *
      *   <dt>context</dt>
      *     <dd>The "`this'" object for all configured event handlers. If a
      *     specific context is needed for individual callbacks, bind the
      *     callback to a context using `Y.bind()`.</dd>
      *
      *   <dt>headers</dt>
      *     <dd>Object map of transaction headers to send to the server. The
      *     object keys are the header names and the values are the header
      *     values.</dd>
      *
      *   <dt>timeout</dt>
      *     <dd>Millisecond threshold for the transaction before being
      *     automatically aborted.</dd>
      *
      *   <dt>arguments</dt>
      *     <dd>User-defined data passed to all registered event handlers.
      *     This value is available as the second argument in the "start" and
      *     "end" event handlers. It is the third argument in the "complete",
      *     "success", and "failure" event handlers. <strong>Be sure to quote
      *     this property name in the transaction configuration as
      *     "arguments" is a reserved word in JavaScript</strong> (e.g.
      *     `Y.io({ ..., "arguments": stuff })`).</dd>
      * </dl>
      *
      * @method send
      * @public
      * @param {String} uri Qualified path to transaction resource.
      * @param {Object} config Configuration object for the transaction.
      * @param {Number} id Transaction id, if already set.
      * @return {Object}
      */
      send: function(uri, config, id) {
          var transaction, method, i, len, sync, data,
              io = this,
              u = uri,
              response = {};
  
          config = config ? Y.Object(config) : {};
          transaction = io._create(config, id);
          method = config.method ? config.method.toUpperCase() : 'GET';
          sync = config.sync;
          data = config.data;
  
          // Serialize an map object into a key-value string using
          // querystring-stringify-simple.
          if ((Y.Lang.isObject(data) && !data.nodeType) && !transaction.upload) {
              data = Y.QueryString.stringify(data);
          }
  
          if (config.form) {
              if (config.form.upload) {
                  // This is a file upload transaction, calling
                  // upload() in io-upload-iframe.
                  return io.upload(transaction, uri, config);
              } else {
                  // Serialize HTML form data into a key-value string.
                  data = io._serialize(config.form, data);
              }
          }
  
          if (data) {
              switch (method) {
                  case 'GET':
                  case 'HEAD':
                  case 'DELETE':
                      u = io._concat(u, data);
                      data = '';
                      break;
                  case 'POST':
                  case 'PUT':
                      // If Content-Type is defined in the configuration object, or
                      // or as a default header, it will be used instead of
                      // 'application/x-www-form-urlencoded; charset=UTF-8'
                      config.headers = Y.merge({
                          'Content-Type': 'application/x-www-form-urlencoded; charset=UTF-8'
                      }, config.headers);
                      break;
              }
          }
  
          if (transaction.xdr) {
              // Route data to io-xdr module for flash and XDomainRequest.
              return io.xdr(u, transaction, config);
          }
          else if (transaction.notify) {
              // Route data to custom transport
              return transaction.c.send(transaction, uri, config);
          }
  
          if (!sync && !transaction.upload) {
              transaction.c.onreadystatechange = function() {
                  io._rS(transaction, config);
              };
          }
  
          try {
              // Determine if request is to be set as
              // synchronous or asynchronous.
              transaction.c.open(method, u, !sync, config.username || null, config.password || null);
              io._setHeaders(transaction.c, config.headers || {});
              io.start(transaction, config);
  
              // Will work only in browsers that implement the
              // Cross-Origin Resource Sharing draft.
              if (config.xdr && config.xdr.credentials) {
                  if (!Y.UA.ie) {
                      transaction.c.withCredentials = true;
                  }
              }
  
              // Using "null" with HTTP POST will result in a request
              // with no Content-Length header defined.
              transaction.c.send(data);
  
              if (sync) {
                  // Create a response object for synchronous transactions,
                  // mixing id and arguments properties with the xhr
                  // properties whitelist.
                  for (i = 0, len = XHR_PROPS.length; i < len; ++i) {
                      response[XHR_PROPS[i]] = transaction.c[XHR_PROPS[i]];
                  }
  
                  response.getAllResponseHeaders = function() {
                      return transaction.c.getAllResponseHeaders();
                  };
  
                  response.getResponseHeader = function(name) {
                      return transaction.c.getResponseHeader(name);
                  };
  
                  io.complete(transaction, config);
                  io._result(transaction, config);
  
                  return response;
              }
          } catch(e) {
              if (transaction.xdr) {
                  // This exception is usually thrown by browsers
                  // that do not support XMLHttpRequest Level 2.
                  // Retry the request with the XDR transport set
                  // to 'flash'.  If the Flash transport is not
                  // initialized or available, the transaction
                  // will resolve to a transport error.
                  return io._retry(transaction, uri, config);
              } else {
                  io.complete(transaction, config);
                  io._result(transaction, config);
              }
          }
  
          // If config.timeout is defined, and the request is standard XHR,
          // initialize timeout polling.
          if (config.timeout) {
              io._startTimeout(transaction, config.timeout);
          }
  
          return {
              id: transaction.id,
              abort: function() {
                  return transaction.c ? io._abort(transaction, 'abort') : false;
              },
              isInProgress: function() {
                  return transaction.c ? (transaction.c.readyState % 4) : false;
              },
              io: io
          };
      }
  };
  
  /**
  Method for initiating an ajax call.  The first argument is the url end
  point for the call.  The second argument is an object to configure the
  transaction and attach event subscriptions.  The configuration object
  supports the following properties:
  
  <dl>
    <dt>method</dt>
      <dd>HTTP method verb (e.g., GET or POST). If this property is not
          not defined, the default value will be GET.</dd>
  
    <dt>data</dt>
      <dd>This is the name-value string that will be sent as the
      transaction data. If the request is HTTP GET, the data become
      part of querystring. If HTTP POST, the data are sent in the
      message body.</dd>
  
    <dt>xdr</dt>
      <dd>Defines the transport to be used for cross-domain requests.
      By setting this property, the transaction will use the specified
      transport instead of XMLHttpRequest. The properties of the
      transport object are:
      <dl>
        <dt>use</dt>
          <dd>The transport to be used: 'flash' or 'native'</dd>
        <dt>dataType</dt>
          <dd>Set the value to 'XML' if that is the expected response
          content type.</dd>
      </dl></dd>
  
    <dt>form</dt>
      <dd>Form serialization configuration object.  Its properties are:
      <dl>
        <dt>id</dt>
          <dd>Node object or id of HTML form</dd>
        <dt>useDisabled</dt>
          <dd>`true` to also serialize disabled form field values
          (defaults to `false`)</dd>
      </dl></dd>
  
    <dt>on</dt>
      <dd>Assigns transaction event subscriptions. Available events are:
      <dl>
        <dt>start</dt>
          <dd>Fires when a request is sent to a resource.</dd>
        <dt>complete</dt>
          <dd>Fires when the transaction is complete.</dd>
        <dt>success</dt>
          <dd>Fires when the HTTP response status is within the 2xx
          range.</dd>
        <dt>failure</dt>
          <dd>Fires when the HTTP response status is outside the 2xx
          range, if an exception occurs, if the transation is aborted,
          or if the transaction exceeds a configured `timeout`.</dd>
        <dt>end</dt>
          <dd>Fires at the conclusion of the transaction
             lifecycle, after `success` or `failure`.</dd>
      </dl>
  
      <p>Callback functions for `start` and `end` receive the id of the
      transaction as a first argument. For `complete`, `success`, and
      `failure`, callbacks receive the id and the response object
      (usually the XMLHttpRequest instance).  If the `arguments`
      property was included in the configuration object passed to
      `Y.io()`, the configured data will be passed to all callbacks as
      the last argument.</p>
      </dd>
  
    <dt>sync</dt>
      <dd>Pass `true` to make a same-domain transaction synchronous.
      <strong>CAVEAT</strong>: This will negatively impact the user
      experience. Have a <em>very</em> good reason if you intend to use
      this.</dd>
  
    <dt>context</dt>
      <dd>The "`this'" object for all configured event handlers. If a
      specific context is needed for individual callbacks, bind the
      callback to a context using `Y.bind()`.</dd>
  
    <dt>headers</dt>
      <dd>Object map of transaction headers to send to the server. The
      object keys are the header names and the values are the header
      values.</dd>
  
    <dt>timeout</dt>
      <dd>Millisecond threshold for the transaction before being
      automatically aborted.</dd>
  
    <dt>arguments</dt>
      <dd>User-defined data passed to all registered event handlers.
      This value is available as the second argument in the "start" and
      "end" event handlers. It is the third argument in the "complete",
      "success", and "failure" event handlers. <strong>Be sure to quote
      this property name in the transaction configuration as
      "arguments" is a reserved word in JavaScript</strong> (e.g.
      `Y.io({ ..., "arguments": stuff })`).</dd>
  </dl>
  
  @method io
  @static
  @param {String} url qualified path to transaction resource.
  @param {Object} config configuration object for the transaction.
  @return {Object}
  @for YUI
  **/
  Y.io = function(url, config) {
      // Calling IO through the static interface will use and reuse
      // an instance of IO.
      var transaction = Y.io._map['io:0'] || new IO();
      return transaction.send.apply(transaction, [url, config]);
  };
  
  /**
  Method for setting and deleting IO HTTP headers to be sent with every
  request.
  
  Hosted as a property on the `io` function (e.g. `Y.io.header`).
  
  @method header
  @param {String} name HTTP header
  @param {String} value HTTP header value
  @static
  **/
  Y.io.header = function(name, value) {
      // Calling IO through the static interface will use and reuse
      // an instance of IO.
      var transaction = Y.io._map['io:0'] || new IO();
      transaction.setHeader(name, value);
  };
  
  Y.IO = IO;
  // Map of all IO instances created.
  Y.io._map = {};
  var XHR = win && win.XMLHttpRequest,
      XDR = win && win.XDomainRequest,
      AX = win && win.ActiveXObject;
  
  
  Y.mix(Y.IO, {
      /**
      * The ID of the default IO transport, defaults to `xhr`
      * @property _default
      * @type {String}
      * @static
      */
      _default: 'xhr',
      /**
      *
      * @method defaultTransport
      * @static
      * @param {String} [id] The transport to set as the default, if empty a new transport is created.
      * @return {Object} The transport object with a `send` method
      */
      defaultTransport: function(id) {
          if (id) {
              Y.IO._default = id;
          } else {
              var o = {
                  c: Y.IO.transports[Y.IO._default](),
                  notify: Y.IO._default === 'xhr' ? false : true
              };
              return o;
          }
      },
      /**
      * An object hash of custom transports available to IO
      * @property transports
      * @type {Object}
      * @static
      */
      transports: {
          xhr: function () {
              return XHR ? new XMLHttpRequest() :
                  AX ? new ActiveXObject('Microsoft.XMLHTTP') : null;
          },
          xdr: function () {
              return XDR ? new XDomainRequest() : null;
          },
          iframe: function () { return {}; },
          flash: null,
          nodejs: null
      },
      /**
      * Create a custom transport of type and return it's object
      * @method customTransport
      * @param {String} id The id of the transport to create.
      * @static
      */
      customTransport: function(id) {
          var o = { c: Y.IO.transports[id]() };
  
          o[(id === 'xdr' || id === 'flash') ? 'xdr' : 'notify'] = true;
          return o;
      }
  });
  
  Y.mix(Y.IO.prototype, {
      /**
      * Fired from the notify method of the transport which in turn fires
      * the event on the IO object.
      * @method notify
      * @param {String} event The name of the event
      * @param {Object} transaction The transaction object
      * @param {Object} config The configuration object for this transaction
      */
      notify: function(event, transaction, config) {
          var io = this;
  
          switch (event) {
              case 'timeout':
              case 'abort':
              case 'transport error':
                  transaction.c = { status: 0, statusText: event };
                  event = 'failure';
              default:
                  io[event].apply(io, [transaction, config]);
          }
      }
  });
  
  
  
  
  }, '@VERSION@' ,{requires:['event-custom-base', 'querystring-stringify-simple']});
  YUI.add('json-parse', function(Y) {
  
  /**
   * <p>The JSON module adds support for serializing JavaScript objects into
   * JSON strings and parsing JavaScript objects from strings in JSON format.</p>
   *
   * <p>The JSON namespace is added to your YUI instance including static methods
   * Y.JSON.parse(..) and Y.JSON.stringify(..).</p>
   *
   * <p>The functionality and method signatures follow the ECMAScript 5
   * specification.  In browsers with native JSON support, the native
   * implementation is used.</p>
   *
   * <p>The <code>json</code> module is a rollup of <code>json-parse</code> and
   * <code>json-stringify</code>.</p>
   * 
   * <p>As their names suggest, <code>json-parse</code> adds support for parsing
   * JSON data (Y.JSON.parse) and <code>json-stringify</code> for serializing
   * JavaScript data into JSON strings (Y.JSON.stringify).  You may choose to
   * include either of the submodules individually if you don't need the
   * complementary functionality, or include the rollup for both.</p>
   *
   * @module json
   * @main json
   * @class JSON
   * @static
   */
  
  /**
   * Provides Y.JSON.parse method to accept JSON strings and return native
   * JavaScript objects.
   *
   * @module json
   * @submodule json-parse
   * @for JSON
   * @static
   */
  
  
  // All internals kept private for security reasons
  function fromGlobal(ref) {
      return (Y.config.win || this || {})[ref];
  }
  
  
      /**
       * Alias to native browser implementation of the JSON object if available.
       *
       * @property Native
       * @type {Object}
       * @private
       */
  var _JSON  = fromGlobal('JSON'),
  
      Native = (Object.prototype.toString.call(_JSON) === '[object JSON]' && _JSON),
      useNative = !!Native,
  
      /**
       * Replace certain Unicode characters that JavaScript may handle incorrectly
       * during eval--either by deleting them or treating them as line
       * endings--with escape sequences.
       * IMPORTANT NOTE: This regex will be used to modify the input if a match is
       * found.
       *
       * @property _UNICODE_EXCEPTIONS
       * @type {RegExp}
       * @private
       */
      _UNICODE_EXCEPTIONS = /[\u0000\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g,
  
  
      /**
       * First step in the safety evaluation.  Regex used to replace all escape
       * sequences (i.e. "\\", etc) with '@' characters (a non-JSON character).
       *
       * @property _ESCAPES
       * @type {RegExp}
       * @private
       */
      _ESCAPES = /\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g,
  
      /**
       * Second step in the safety evaluation.  Regex used to replace all simple
       * values with ']' characters.
       *
       * @property _VALUES
       * @type {RegExp}
       * @private
       */
      _VALUES  = /"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g,
  
      /**
       * Third step in the safety evaluation.  Regex used to remove all open
       * square brackets following a colon, comma, or at the beginning of the
       * string.
       *
       * @property _BRACKETS
       * @type {RegExp}
       * @private
       */
      _BRACKETS = /(?:^|:|,)(?:\s*\[)+/g,
  
      /**
       * Final step in the safety evaluation.  Regex used to test the string left
       * after all previous replacements for invalid characters.
       *
       * @property _UNSAFE
       * @type {RegExp}
       * @private
       */
      _UNSAFE = /[^\],:{}\s]/,
      
      /**
       * Replaces specific unicode characters with their appropriate \unnnn
       * format. Some browsers ignore certain characters during eval.
       *
       * @method escapeException
       * @param c {String} Unicode character
       * @return {String} the \unnnn escapement of the character
       * @private
       */
      _escapeException = function (c) {
          return '\\u'+('0000'+(+(c.charCodeAt(0))).toString(16)).slice(-4);
      },
  
      /**
       * Traverses nested objects, applying a reviver function to each (key,value)
       * from the scope if the key:value's containing object.  The value returned
       * from the function will replace the original value in the key:value pair.
       * If the value returned is undefined, the key will be omitted from the
       * returned object.
       *
       * @method _revive
       * @param data {MIXED} Any JavaScript data
       * @param reviver {Function} filter or mutation function
       * @return {MIXED} The results of the filtered data
       * @private
       */
      _revive = function (data, reviver) {
          var walk = function (o,key) {
              var k,v,value = o[key];
              if (value && typeof value === 'object') {
                  for (k in value) {
                      if (value.hasOwnProperty(k)) {
                          v = walk(value, k);
                          if (v === undefined) {
                              delete value[k];
                          } else {
                              value[k] = v;
                          }
                      }
                  }
              }
              return reviver.call(o,key,value);
          };
  
          return typeof reviver === 'function' ? walk({'':data},'') : data;
      },
  
      /**
       * Parse a JSON string, returning the native JavaScript representation.
       *
       * @param s {string} JSON string data
       * @param reviver {function} (optional) function(k,v) passed each key value
       *          pair of object literals, allowing pruning or altering values
       * @return {MIXED} the native JavaScript representation of the JSON string
       * @throws SyntaxError
       * @method parse
       * @static
       */
      // JavaScript implementation in lieu of native browser support.  Based on
      // the json2.js library from http://json.org
      _parse = function (s,reviver) {
          // Replace certain Unicode characters that are otherwise handled
          // incorrectly by some browser implementations.
          // NOTE: This modifies the input if such characters are found!
          s = s.replace(_UNICODE_EXCEPTIONS, _escapeException);
          
          // Test for any remaining invalid characters
          if (!_UNSAFE.test(s.replace(_ESCAPES,'@').
                              replace(_VALUES,']').
                              replace(_BRACKETS,''))) {
  
              // Eval the text into a JavaScript data structure, apply any
              // reviver function, and return
              return _revive( eval('(' + s + ')'), reviver );
          }
  
          throw new SyntaxError('JSON.parse');
      };
      
  Y.namespace('JSON').parse = function (s,reviver) {
          if (typeof s !== 'string') {
              s += '';
          }
  
          return Native && Y.JSON.useNativeParse ?
              Native.parse(s,reviver) : _parse(s,reviver);
  };
  
  function workingNative( k, v ) {
      return k === "ok" ? true : v;
  }
  
  // Double check basic functionality.  This is mainly to catch early broken
  // implementations of the JSON API in Firefox 3.1 beta1 and beta2
  if ( Native ) {
      try {
          useNative = ( Native.parse( '{"ok":false}', workingNative ) ).ok;
      }
      catch ( e ) {
          useNative = false;
      }
  }
  
  /**
   * Leverage native JSON parse if the browser has a native implementation.
   * In general, this is a good idea.  See the Known Issues section in the
   * JSON user guide for caveats.  The default value is true for browsers with
   * native JSON support.
   *
   * @property useNativeParse
   * @type Boolean
   * @default true
   * @static
   */
  Y.JSON.useNativeParse = useNative;
  
  
  }, '@VERSION@' ,{requires:['yui-base']});
  YUI.add('transition', function(Y) {
  
  /**
  * Provides the transition method for Node.
  * Transition has no API of its own, but adds the transition method to Node.
  *
  * @module transition
  * @requires node-style
  */
  
  var CAMEL_VENDOR_PREFIX = '',
      VENDOR_PREFIX = '',
      DOCUMENT = Y.config.doc,
      DOCUMENT_ELEMENT = 'documentElement',
      TRANSITION = 'transition',
      TRANSITION_CAMEL = 'Transition',
      TRANSITION_PROPERTY_CAMEL,
      TRANSITION_PROPERTY,
      TRANSITION_DURATION,
      TRANSITION_TIMING_FUNCTION,
      TRANSITION_DELAY,
      TRANSITION_END,
      ON_TRANSITION_END,
      TRANSFORM_CAMEL,
  
      EMPTY_OBJ = {},
  
      VENDORS = [
          'Webkit',
          'Moz'
      ],
  
      VENDOR_TRANSITION_END = {
          Webkit: 'webkitTransitionEnd'
      },
  
  /**
   * A class for constructing transition instances.
   * Adds the "transition" method to Node.
   * @class Transition
   * @constructor
   */
  
  Transition = function() {
      this.init.apply(this, arguments);
  };
  
  Transition._toCamel = function(property) {
      property = property.replace(/-([a-z])/gi, function(m0, m1) {
          return m1.toUpperCase();
      });
  
      return property;
  };
  
  Transition._toHyphen = function(property) {
      property = property.replace(/([A-Z]?)([a-z]+)([A-Z]?)/g, function(m0, m1, m2, m3) {
          var str = ((m1) ? '-' + m1.toLowerCase() : '') + m2;
          
          if (m3) {
              str += '-' + m3.toLowerCase();
          }
  
          return str;
      }); 
  
      return property;
  };
  
  Transition.SHOW_TRANSITION = 'fadeIn';
  Transition.HIDE_TRANSITION = 'fadeOut';
  
  Transition.useNative = false;
  
  Y.Array.each(VENDORS, function(val) { // then vendor specific
      var property = val + TRANSITION_CAMEL;
      if (property in DOCUMENT[DOCUMENT_ELEMENT].style) {
          CAMEL_VENDOR_PREFIX = val;
          VENDOR_PREFIX = Transition._toHyphen(val) + '-';
  
          Transition.useNative = true;
          Transition.supported = true; // TODO: remove
          Transition._VENDOR_PREFIX = val;
      }
  });
  
  TRANSITION_CAMEL = CAMEL_VENDOR_PREFIX + TRANSITION_CAMEL;
  TRANSITION_PROPERTY_CAMEL = CAMEL_VENDOR_PREFIX + 'TransitionProperty';
  TRANSITION_PROPERTY = VENDOR_PREFIX + 'transition-property';
  TRANSITION_DURATION = VENDOR_PREFIX + 'transition-duration';
  TRANSITION_TIMING_FUNCTION = VENDOR_PREFIX + 'transition-timing-function';
  TRANSITION_DELAY = VENDOR_PREFIX + 'transition-delay';
  TRANSITION_END = 'transitionend';
  ON_TRANSITION_END = 'on' + CAMEL_VENDOR_PREFIX.toLowerCase() + 'transitionend';
  
  TRANSITION_END = VENDOR_TRANSITION_END[CAMEL_VENDOR_PREFIX] || TRANSITION_END;
  
  TRANSFORM_CAMEL = CAMEL_VENDOR_PREFIX + 'Transform';
  
  Transition.fx = {};
  Transition.toggles = {};
  
  Transition._hasEnd = {};
  
  Transition._reKeywords = /^(?:node|duration|iterations|easing|delay|on|onstart|onend)$/i;
  
  Y.Node.DOM_EVENTS[TRANSITION_END] = 1; 
  
  Transition.NAME = 'transition';
  
  Transition.DEFAULT_EASING = 'ease';
  Transition.DEFAULT_DURATION = 0.5;
  Transition.DEFAULT_DELAY = 0;
  
  Transition._nodeAttrs = {};
  
  Transition.prototype = {
      constructor: Transition,
      init: function(node, config) {
          var anim = this;
          anim._node = node;
          if (!anim._running && config) {
              anim._config = config;
              node._transition = anim; // cache for reuse
  
              anim._duration = ('duration' in config) ?
                  config.duration: anim.constructor.DEFAULT_DURATION;
  
              anim._delay = ('delay' in config) ?
                  config.delay: anim.constructor.DEFAULT_DELAY;
  
              anim._easing = config.easing || anim.constructor.DEFAULT_EASING;
              anim._count = 0; // track number of animated properties
              anim._running = false;
  
          }
  
          return anim;
      },
  
      addProperty: function(prop, config) {
          var anim = this,
              node = this._node,
              uid = Y.stamp(node),
              nodeInstance = Y.one(node),
              attrs = Transition._nodeAttrs[uid],
              computed,
              compareVal,
              dur,
              attr,
              val;
  
          if (!attrs) {
              attrs = Transition._nodeAttrs[uid] = {};
          }
  
          attr = attrs[prop];
  
          // might just be a value
          if (config && config.value !== undefined) {
              val = config.value;
          } else if (config !== undefined) {
              val = config; 
              config = EMPTY_OBJ;
          }
  
          if (typeof val === 'function') {
              val = val.call(nodeInstance, nodeInstance);
          }
  
          if (attr && attr.transition) {
              // take control if another transition owns this property
              if (attr.transition !== anim) {
                  attr.transition._count--; // remapping attr to this transition
              }
          } 
  
          anim._count++; // properties per transition
  
          // make 0 async and fire events
          dur = ((typeof config.duration != 'undefined') ? config.duration :
                      anim._duration) || 0.0001;
  
          attrs[prop] = {
              value: val,
              duration: dur,
              delay: (typeof config.delay != 'undefined') ? config.delay :
                      anim._delay,
  
              easing: config.easing || anim._easing,
  
              transition: anim
          };
  
          // native end event doesnt fire when setting to same value
          // supplementing with timer
          // val may be a string or number (height: 0, etc), but computedStyle is always string
          computed = Y.DOM.getComputedStyle(node, prop);
          compareVal = (typeof val === 'string') ? computed : parseFloat(computed);
  
          if (Transition.useNative && compareVal === val) {
              setTimeout(function() {
                  anim._onNativeEnd.call(node, {
                      propertyName: prop,
                      elapsedTime: dur
                  });
              }, dur * 1000);
          }
      },
  
      removeProperty: function(prop) {
          var anim = this,
              attrs = Transition._nodeAttrs[Y.stamp(anim._node)];
  
          if (attrs && attrs[prop]) {
              delete attrs[prop];
              anim._count--;
          }
  
      },
  
      initAttrs: function(config) {
          var attr,
              node = this._node;
  
          if (config.transform && !config[TRANSFORM_CAMEL]) {
              config[TRANSFORM_CAMEL] = config.transform;
              delete config.transform; // TODO: copy
          }
  
          for (attr in config) {
              if (config.hasOwnProperty(attr) && !Transition._reKeywords.test(attr)) {
                  this.addProperty(attr, config[attr]);
  
                  // when size is auto or % webkit starts from zero instead of computed 
                  // (https://bugs.webkit.org/show_bug.cgi?id=16020)
                  // TODO: selective set
                  if (node.style[attr] === '') {
                      Y.DOM.setStyle(node, attr, Y.DOM.getComputedStyle(node, attr));
                  }
              }
          }
      },
  
      /**
       * Starts or an animation.
       * @method run
       * @chainable
       * @private
       */    
      run: function(callback) {
          var anim = this,
              node = anim._node,
              config = anim._config,
              data = {
                  type: 'transition:start',
                  config: config
              };
  
  
          if (!anim._running) {
              anim._running = true;
  
              if (config.on && config.on.start) {
                  config.on.start.call(Y.one(node), data);
              }
  
              anim.initAttrs(anim._config);
  
              anim._callback = callback;
              anim._start();
          }
  
  
          return anim;
      },
  
      _start: function() {
          this._runNative();
      },
  
      _prepDur: function(dur) {
          dur = parseFloat(dur);
  
          return dur + 's';
      },
  
      _runNative: function(time) {
          var anim = this,
              node = anim._node,
              uid = Y.stamp(node),
              style = node.style,
              computed = node.ownerDocument.defaultView.getComputedStyle(node),
              attrs = Transition._nodeAttrs[uid],
              cssText = '',
              cssTransition = computed[Transition._toCamel(TRANSITION_PROPERTY)],
  
              transitionText = TRANSITION_PROPERTY + ': ',
              duration = TRANSITION_DURATION + ': ',
              easing = TRANSITION_TIMING_FUNCTION + ': ',
              delay = TRANSITION_DELAY + ': ',
              hyphy,
              attr,
              name;
  
          // preserve existing transitions
          if (cssTransition !== 'all') {
              transitionText += cssTransition + ',';
              duration += computed[Transition._toCamel(TRANSITION_DURATION)] + ',';
              easing += computed[Transition._toCamel(TRANSITION_TIMING_FUNCTION)] + ',';
              delay += computed[Transition._toCamel(TRANSITION_DELAY)] + ',';
  
          }
  
          // run transitions mapped to this instance
          for (name in attrs) {
              hyphy = Transition._toHyphen(name);
              attr = attrs[name];
              if ((attr = attrs[name]) && attr.transition === anim) {
                  if (name in node.style) { // only native styles allowed
                      duration += anim._prepDur(attr.duration) + ',';
                      delay += anim._prepDur(attr.delay) + ',';
                      easing += (attr.easing) + ',';
  
                      transitionText += hyphy + ',';
                      cssText += hyphy + ': ' + attr.value + '; ';
                  } else {
                      this.removeProperty(name);
                  }
              }
          }
  
          transitionText = transitionText.replace(/,$/, ';');
          duration = duration.replace(/,$/, ';');
          easing = easing.replace(/,$/, ';');
          delay = delay.replace(/,$/, ';');
  
          // only one native end event per node
          if (!Transition._hasEnd[uid]) {
              node.addEventListener(TRANSITION_END, anim._onNativeEnd, '');
              Transition._hasEnd[uid] = true;
  
          }
          
          style.cssText += transitionText + duration + easing + delay + cssText;
  
      },
  
      _end: function(elapsed) {
          var anim = this,
              node = anim._node,
              callback = anim._callback,
              config = anim._config,
              data = {
                  type: 'transition:end',
                  config: config,
                  elapsedTime: elapsed 
              },
  
              nodeInstance = Y.one(node); 
  
          anim._running = false;
          anim._callback = null;
  
          if (node) {
              if (config.on && config.on.end) {
                  setTimeout(function() { // IE: allow previous update to finish
                      config.on.end.call(nodeInstance, data);
  
                      // nested to ensure proper fire order
                      if (callback) {
                          callback.call(nodeInstance, data);
                      }
  
                  }, 1);
              } else if (callback) {
                  setTimeout(function() { // IE: allow previous update to finish
                      callback.call(nodeInstance, data);
                  }, 1);
              }
          }
  
      },
  
      _endNative: function(name) {
          var node = this._node,
              value = node.ownerDocument.defaultView.getComputedStyle(node, '')[Transition._toCamel(TRANSITION_PROPERTY)];
  
          name = Transition._toHyphen(name);
          if (typeof value === 'string') {
              value = value.replace(new RegExp('(?:^|,\\s)' + name + ',?'), ',');
              value = value.replace(/^,|,$/, '');
              node.style[TRANSITION_CAMEL] = value;
          }
      },
  
      _onNativeEnd: function(e) {
          var node = this,
              uid = Y.stamp(node),
              event = e,//e._event,
              name = Transition._toCamel(event.propertyName),
              elapsed = event.elapsedTime,
              attrs = Transition._nodeAttrs[uid],
              attr = attrs[name],
              anim = (attr) ? attr.transition : null,
              data,
              config;
  
          if (anim) {
              anim.removeProperty(name);
              anim._endNative(name);
              config = anim._config[name];
  
              data = {
                  type: 'propertyEnd',
                  propertyName: name,
                  elapsedTime: elapsed,
                  config: config
              };
  
              if (config && config.on && config.on.end) {
                  config.on.end.call(Y.one(node), data);
              }
  
              if (anim._count <= 0)  { // after propertyEnd fires
                  anim._end(elapsed);
                  node.style[TRANSITION_PROPERTY_CAMEL] = ''; // clean up style
              }
          }
      },
  
      destroy: function() {
          var anim = this,
              node = anim._node;
  
          if (node) {
              node.removeEventListener(TRANSITION_END, anim._onNativeEnd, false);
              anim._node = null;
          }
      }
  };
  
  Y.Transition = Transition;
  Y.TransitionNative = Transition; // TODO: remove
  
  /** 
   *   Animate one or more css properties to a given value. Requires the "transition" module.
   *   <pre>example usage:
   *       Y.one('#demo').transition({
   *           duration: 1, // in seconds, default is 0.5
   *           easing: 'ease-out', // default is 'ease'
   *           delay: '1', // delay start for 1 second, default is 0
   *
   *           height: '10px',
   *           width: '10px',
   *
   *           opacity: { // per property
   *               value: 0,
   *               duration: 2,
   *               delay: 2,
   *               easing: 'ease-in'
   *           }
   *       });
   *   </pre>
   *   @for Node
   *   @method transition
   *   @param {Object} config An object containing one or more style properties, a duration and an easing.
   *   @param {Function} callback A function to run after the transition has completed. 
   *   @chainable
  */
  Y.Node.prototype.transition = function(name, config, callback) {
      var 
          transitionAttrs = Transition._nodeAttrs[Y.stamp(this._node)],
          anim = (transitionAttrs) ? transitionAttrs.transition || null : null,
          fxConfig,
          prop;
      
      if (typeof name === 'string') { // named effect, pull config from registry
          if (typeof config === 'function') {
              callback = config;
              config = null;
          }
  
          fxConfig = Transition.fx[name];
  
          if (config && typeof config !== 'boolean') {
              config = Y.clone(config);
  
              for (prop in fxConfig) {
                  if (fxConfig.hasOwnProperty(prop)) {
                      if (! (prop in config)) {
                          config[prop] = fxConfig[prop]; 
                      }
                  }
              }
          } else {
              config = fxConfig;
          }
  
      } else { // name is a config, config is a callback or undefined
          callback = config;
          config = name;
      }
  
      if (anim && !anim._running) {
          anim.init(this, config);
      } else {
          anim = new Transition(this._node, config);
      }
  
      anim.run(callback);
      return this;
  };
  
  Y.Node.prototype.show = function(name, config, callback) {
      this._show(); // show prior to transition
      if (name && Y.Transition) {
          if (typeof name !== 'string' && !name.push) { // named effect or array of effects supercedes default
              if (typeof config === 'function') {
                  callback = config;
                  config = name;
              }
              name = Transition.SHOW_TRANSITION; 
          }    
          this.transition(name, config, callback);
      }    
      return this;
  };
  
  var _wrapCallBack = function(anim, fn, callback) {
      return function() {
          if (fn) {
              fn.call(anim);
          }
          if (callback) {
              callback.apply(anim._node, arguments);
          }
      };
  };
  
  Y.Node.prototype.hide = function(name, config, callback) {
      if (name && Y.Transition) {
          if (typeof config === 'function') {
              callback = config;
              config = null;
          }
  
          callback = _wrapCallBack(this, this._hide, callback); // wrap with existing callback
          if (typeof name !== 'string' && !name.push) { // named effect or array of effects supercedes default
              if (typeof config === 'function') {
                  callback = config;
                  config = name;
              }
              name = Transition.HIDE_TRANSITION; 
          }    
          this.transition(name, config, callback);
      } else {
          this._hide();
      }    
      return this;
  }; 
  
  /** 
   *   Animate one or more css properties to a given value. Requires the "transition" module.
   *   <pre>example usage:
   *       Y.all('.demo').transition({
   *           duration: 1, // in seconds, default is 0.5
   *           easing: 'ease-out', // default is 'ease'
   *           delay: '1', // delay start for 1 second, default is 0
   *
   *           height: '10px',
   *           width: '10px',
   *
   *           opacity: { // per property
   *               value: 0,
   *               duration: 2,
   *               delay: 2,
   *               easing: 'ease-in'
   *           }
   *       });
   *   </pre>
   *   @for NodeList
   *   @method transition
   *   @param {Object} config An object containing one or more style properties, a duration and an easing.
   *   @param {Function} callback A function to run after the transition has completed. The callback fires
   *       once per item in the NodeList.
   *   @chainable
  */
  Y.NodeList.prototype.transition = function(config, callback) {
      var nodes = this._nodes,
          i = 0,
          node;
  
      while ((node = nodes[i++])) {
          Y.one(node).transition(config, callback);
      }
  
      return this;
  };
  
  Y.Node.prototype.toggleView = function(name, on, callback) {
      this._toggles = this._toggles || [];
      callback = arguments[arguments.length - 1];
  
      if (typeof name == 'boolean') { // no transition, just toggle
          on = name;
          name = null;
      }
  
      name = name || Y.Transition.DEFAULT_TOGGLE;
  
      if (typeof on == 'undefined' && name in this._toggles) { // reverse current toggle
          on = ! this._toggles[name];
      }
  
      on = (on) ? 1 : 0;
      if (on) {
          this._show();
      }  else {
          callback = _wrapCallBack(this, this._hide, callback);
      }
  
      this._toggles[name] = on;
      this.transition(Y.Transition.toggles[name][on], callback);
  
      return this;
  };
  
  Y.NodeList.prototype.toggleView = function(name, on, callback) {
      var nodes = this._nodes,
          i = 0,
          node;
  
      while ((node = nodes[i++])) {
          Y.one(node).toggleView(name, on, callback);
      }
  
      return this;
  };
  
  Y.mix(Transition.fx, {
      fadeOut: {
          opacity: 0,
          duration: 0.5,
          easing: 'ease-out'
      },
  
      fadeIn: {
          opacity: 1,
          duration: 0.5,
          easing: 'ease-in'
      },
  
      sizeOut: {
          height: 0,
          width: 0,
          duration: 0.75,
          easing: 'ease-out'
      },
  
      sizeIn: {
          height: function(node) {
              return node.get('scrollHeight') + 'px';
          },
          width: function(node) {
              return node.get('scrollWidth') + 'px';
          },
          duration: 0.5,
          easing: 'ease-in',
          
          on: {
              start: function() {
                  var overflow = this.getStyle('overflow');
                  if (overflow !== 'hidden') { // enable scrollHeight/Width
                      this.setStyle('overflow', 'hidden');
                      this._transitionOverflow = overflow;
                  }
              },
  
              end: function() {
                  if (this._transitionOverflow) { // revert overridden value
                      this.setStyle('overflow', this._transitionOverflow);
                      delete this._transitionOverflow;
                  }
              }
          } 
      }
  });
  
  Y.mix(Transition.toggles, {
      size: ['sizeOut', 'sizeIn'],
      fade: ['fadeOut', 'fadeIn']
  });
  
  Transition.DEFAULT_TOGGLE = 'fade';
  
  
  
  }, '@VERSION@' ,{requires:['node-style']});
  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',
  
      Selector = Y.Selector,
  
      SelectorCSS2 = {
          _reRegExpTokens: /([\^\$\?\[\]\*\+\-\.\(\)\|\\])/,
          SORT_RESULTS: true,
  
          // TODO: better detection, document specific
          _isXML: (function() {
              var isXML = (Y.config.doc.createElement('div').tagName !== 'DIV');
              return isXML;
          }()),
  
          /**
           * Mapping of shorthand tokens to corresponding attribute selector 
           * @property shorthand
           * @type object
           */
          shorthand: {
              '\\#(-?[_a-z0-9]+[-\\w\\uE000]*)': '[id=$1]',
              '\\.(-?[_a-z]+[-\\w\\uE000]*)': '[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, attr) { return Y.DOM.getAttribute(node, attr) !== ''; }, // Just test for existence of attribute
              '~=': '(?:^|\\s+){val}(?:\\s+|$)', // space-delimited
              '|=': '^{val}-?' // optional hyphen-delimited
          },
  
          pseudos: {
             'first-child': function(node) { 
                  return Y.DOM._children(node[PARENT_NODE])[0] === node; 
              } 
          },
  
          _bruteQuery: function(selector, root, firstOnly) {
              var ret = [],
                  nodes = [],
                  tokens = Selector._tokenize(selector),
                  token = tokens[tokens.length - 1],
                  rootDoc = Y.DOM._getDoc(root),
                  child,
                  id,
                  className,
                  tagName;
  
              if (token) {
                  // prefilter nodes
                  id = token.id;
                  className = token.className;
                  tagName = token.tagName || '*';
  
                  if (root.getElementsByTagName) { // non-IE lacks DOM api on doc frags
                      // try ID first, unless no root.all && root not in document
                      // (root.all works off document, but not getElementById)
                      if (id && (root.all || (root.nodeType === 9 || Y.DOM.inDoc(root)))) {
                          nodes = Y.DOM.allById(id, root);
                      // try className
                      } else if (className) {
                          nodes = root.getElementsByClassName(className);
                      } else { // default to tagName
                          nodes = root.getElementsByTagName(tagName);
                      }
  
                  } else { // brute getElementsByTagName()
                      child = root.firstChild;
                      while (child) {
                          // only collect HTMLElements
                          // match tag to supplement missing getElementsByTagName
                          if (child.tagName && (tagName === '*' || child.tagName === tagName)) {
                              nodes.push(child);
                          }
                          child = child.nextSibling || child.firstChild;
                      }
                  }
                  if (nodes.length) {
                      ret = Selector._filterNodes(nodes, tokens, firstOnly);
                  }
              }
  
              return ret;
          },
          
          _filterNodes: function(nodes, tokens, firstOnly) {
              var i = 0,
                  j,
                  len = tokens.length,
                  n = len - 1,
                  result = [],
                  node = nodes[0],
                  tmpNode = node,
                  getters = Y.Selector.getters,
                  operator,
                  combinator,
                  token,
                  path,
                  pass,
                  value,
                  tests,
                  test;
  
              for (i = 0; (tmpNode = node = nodes[i++]);) {
                  n = len - 1;
                  path = null;
                  
                  testLoop:
                  while (tmpNode && tmpNode.tagName) {
                      token = tokens[n];
                      tests = token.tests;
                      j = tests.length;
                      if (j && !pass) {
                          while ((test = tests[--j])) {
                              operator = test[1];
                              if (getters[test[0]]) {
                                  value = getters[test[0]](tmpNode, test[0]);
                              } else {
                                  value = tmpNode[test[0]];
                                  if (test[0] === 'tagName' && !Selector._isXML) {
                                      value = value.toUpperCase();    
                                  }
                                  if (typeof value != 'string' && value !== undefined && value.toString) {
                                      value = value.toString(); // coerce for comparison
                                  } else if (value === undefined && tmpNode.getAttribute) {
                                      // use getAttribute for non-standard attributes
                                      value = tmpNode.getAttribute(test[0], 2); // 2 === force string for IE
                                  }
                              }
  
                              if ((operator === '=' && value !== test[2]) ||  // fast path for equality
                                  (typeof operator !== 'string' && // protect against String.test monkey-patch (Moo)
                                  operator.test && !operator.test(value)) ||  // regex test
                                  (!operator.test && // protect against RegExp as function (webkit)
                                          typeof operator === 'function' && !operator(tmpNode, test[0], test[2]))) { // function test
  
                                  // skip non element nodes or non-matching tags
                                  if ((tmpNode = tmpNode[path])) {
                                      while (tmpNode &&
                                          (!tmpNode.tagName ||
                                              (token.tagName && token.tagName !== tmpNode.tagName))
                                      ) {
                                          tmpNode = tmpNode[path]; 
                                      }
                                  }
                                  continue testLoop;
                              }
                          }
                      }
  
                      n--; // move to next token
                      // now that we've passed the test, move up the tree by combinator
                      if (!pass && (combinator = token.combinator)) {
                          path = combinator.axis;
                          tmpNode = tmpNode[path];
  
                          // skip non element nodes
                          while (tmpNode && !tmpNode.tagName) {
                              tmpNode = tmpNode[path]; 
                          }
  
                          if (combinator.direct) { // one pass only
                              path = null; 
                          }
  
                      } else { // success if we made it this far
                          result.push(node);
                          if (firstOnly) {
                              return result;
                          }
                          break;
                      }
                  }
              }
              node = tmpNode = null;
              return result;
          },
  
          combinators: {
              ' ': {
                  axis: 'parentNode'
              },
  
              '>': {
                  axis: 'parentNode',
                  direct: true
              },
  
  
              '+': {
                  axis: 'previousSibling',
                  direct: true
              }
          },
  
          _parsers: [
              {
                  name: ATTRIBUTES,
                  re: /^\uE003(-?[a-z]+[\w\-]*)+([~\|\^\$\*!=]=?)?['"]?([^\uE004'"]*)['"]?\uE004/i,
                  fn: function(match, token) {
                      var operator = match[2] || '',
                          operators = Selector.operators,
                          escVal = (match[3]) ? match[3].replace(/\\/g, '') : '',
                          test;
  
                      // add prefiltering for ID and CLASS
                      if ((match[1] === 'id' && operator === '=') ||
                              (match[1] === 'className' &&
                              Y.config.doc.documentElement.getElementsByClassName &&
                              (operator === '~=' || operator === '='))) {
                          token.prefilter = match[1];
  
  
                          match[3] = escVal; 
  
                          // escape all but ID for prefilter, which may run through QSA (via Dom.allById)
                          token[match[1]] = (match[1] === 'id') ? match[3] : escVal;
  
                      }
  
                      // add tests
                      if (operator in operators) {
                          test = operators[operator];
                          if (typeof test === 'string') {
                              match[3] = escVal.replace(Selector._reRegExpTokens, '\\$1');
                              test = new RegExp(test.replace('{val}', match[3]));
                          }
                          match[2] = test;
                      }
                      if (!token.last || token.prefilter !== match[1]) {
                          return match.slice(1);
                      }
                  }
              },
              {
                  name: TAG_NAME,
                  re: /^((?:-?[_a-z]+[\w-]*)|\*)/i,
                  fn: function(match, token) {
                      var tag = match[1];
  
                      if (!Selector._isXML) {
                          tag = tag.toUpperCase();
                      }
  
                      token.tagName = tag;
  
                      if (tag !== '*' && (!token.last || token.prefilter)) {
                          return [TAG_NAME, '=', tag];
                      }
                      if (!token.prefilter) {
                          token.prefilter = 'tagName';
                      }
                  }
              },
              {
                  name: COMBINATOR,
                  re: /^\s*([>+~]|\s)\s*/,
                  fn: function(match, token) {
                  }
              },
              {
                  name: PSEUDOS,
                  re: /^:([\-\w]+)(?:\uE005['"]?([^\uE005]*)['"]?\uE006)*/i,
                  fn: function(match, token) {
                      var test = Selector[PSEUDOS][match[1]];
                      if (test) { // reorder match array and unescape special chars for tests
                          if (match[2]) {
                              match[2] = match[2].replace(/\\/g, '');
                          }
                          return [match[2], test]; 
                      } else { // selector token not supported (possibly missing CSS3 module)
                          return false;
                      }
                  }
              }
              ],
  
          _getToken: function(token) {
              return {
                  tagName: null,
                  id: null,
                  className: null,
                  attributes: {},
                  combinator: null,
                  tests: []
              };
          },
  
          /*
              Break selector into token units per simple selector.
              Combinator is attached to the previous token.
           */
          _tokenize: function(selector) {
              selector = selector || '';
              selector = Selector._parseSelector(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
                  match,         // the regex match
                  test,
                  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 = Selector._parsers[i++]);) {
                      if ( (match = parser.re.exec(selector)) ) { // note assignment
                          if (parser.name !== COMBINATOR ) {
                              token.selector = selector;
                          }
                          selector = selector.replace(match[0], ''); // strip current match from selector
                          if (!selector.length) {
                              token.last = true;
                          }
  
                          if (Selector._attrFilters[match[1]]) { // convert class to className, etc.
                              match[1] = Selector._attrFilters[match[1]];
                          }
  
                          test = parser.fn(match, token);
                          if (test === false) { // selector not supported
                              found = false;
                              break outer;
                          } else if (test) {
                              token.tests.push(test);
                          }
  
                          if (!selector.length || parser.name === COMBINATOR) {
                              tokens.push(token);
                              token = Selector._getToken(token);
                              if (parser.name === COMBINATOR) {
                                  token.combinator = Y.Selector.combinators[match[1]];
                              }
                          }
                          found = true;
                      }
                  }
              } while (found && selector.length);
  
              if (!found || selector.length) { // not fully parsed
                  tokens = [];
              }
              return tokens;
          },
  
          _replaceMarkers: function(selector) {
              selector = selector.replace(/\[/g, '\uE003');
              selector = selector.replace(/\]/g, '\uE004');
  
              selector = selector.replace(/\(/g, '\uE005');
              selector = selector.replace(/\)/g, '\uE006');
              return selector;
          },
  
          _replaceShorthand: function(selector) {
              var shorthand = Y.Selector.shorthand,
                  re;
  
              for (re in shorthand) {
                  if (shorthand.hasOwnProperty(re)) {
                      selector = selector.replace(new RegExp(re, 'gi'), shorthand[re]);
                  }
              }
  
              return selector;
          },
  
          _parseSelector: function(selector) {
              var replaced = Y.Selector._replaceSelector(selector),
                  selector = replaced.selector;
  
              // replace shorthand (".foo, #bar") after pseudos and attrs
              // to avoid replacing unescaped chars
              selector = Y.Selector._replaceShorthand(selector);
  
              selector = Y.Selector._restore('attr', selector, replaced.attrs);
              selector = Y.Selector._restore('pseudo', selector, replaced.pseudos);
  
              // replace braces and parens before restoring escaped chars
              // to avoid replacing ecaped markers
              selector = Y.Selector._replaceMarkers(selector);
              selector = Y.Selector._restore('esc', selector, replaced.esc);
  
              return selector;
          },
  
          _attrFilters: {
              'class': 'className',
              'for': 'htmlFor'
          },
  
          getters: {
              href: function(node, attr) {
                  return Y.DOM.getAttribute(node, attr);
              },
  
              id: function(node, attr) {
                  return Y.DOM.getId(node);
              }
          }
      };
  
  Y.mix(Y.Selector, SelectorCSS2, true);
  Y.Selector.getters.src = Y.Selector.getters.rel = Y.Selector.getters.href;
  
  // IE wants class with native queries
  if (Y.Selector.useNative && Y.config.doc.querySelector) {
      Y.Selector.shorthand['\\.(-?[_a-z]+[-\\w]*)'] = '[class~=$1]';
  }
  
  
  
  }, '@VERSION@' ,{requires:['selector-native']});
  YUI.add('selector-css3', function(Y) {
  
  /**
   * The selector css3 module provides support for css3 selectors.
   * @module dom
   * @submodule selector-css3
   * @for Selector
   */
  
  /*
      an+b = get every _a_th node starting at the _b_th
      0n+b = no repeat ("0" and "n" may both be omitted (together) , e.g. "0n+1" or "1", not "0+1"), return only the _b_th element
      1n+b =  get every element starting from b ("1" may may be omitted, e.g. "1n+0" or "n+0" or "n")
      an+0 = get every _a_th element, "0" may be omitted 
  */
  
  Y.Selector._reNth = /^(?:([\-]?\d*)(n){1}|(odd|even)$)*([\-+]?\d*)$/;
  
  Y.Selector._getNth = function(node, expr, tag, reverse) {
      Y.Selector._reNth.test(expr);
      var a = parseInt(RegExp.$1, 10), // include every _a_ elements (zero means no repeat, just first _a_)
          n = RegExp.$2, // "n"
          oddeven = RegExp.$3, // "odd" or "even"
          b = parseInt(RegExp.$4, 10) || 0, // start scan from element _b_
          result = [],
          siblings = Y.DOM._children(node.parentNode, tag),
          op;
  
      if (oddeven) {
          a = 2; // always every other
          op = '+';
          n = 'n';
          b = (oddeven === 'odd') ? 1 : 0;
      } else if ( isNaN(a) ) {
          a = (n) ? 1 : 0; // start from the first or no repeat
      }
  
      if (a === 0) { // just the first
          if (reverse) {
              b = siblings.length - b + 1; 
          }
  
          if (siblings[b - 1] === node) {
              return true;
          } else {
              return false;
          }
  
      } else if (a < 0) {
          reverse = !!reverse;
          a = Math.abs(a);
      }
  
      if (!reverse) {
          for (var i = b - 1, len = siblings.length; i < len; i += a) {
              if ( i >= 0 && siblings[i] === node ) {
                  return true;
              }
          }
      } else {
          for (var i = siblings.length - b, len = siblings.length; i >= 0; i -= a) {
              if ( i < len && siblings[i] === node ) {
                  return true;
              }
          }
      }
      return false;
  };
  
  Y.mix(Y.Selector.pseudos, {
      'root': function(node) {
          return node === node.ownerDocument.documentElement;
      },
  
      'nth-child': function(node, expr) {
          return Y.Selector._getNth(node, expr);
      },
  
      'nth-last-child': function(node, expr) {
          return Y.Selector._getNth(node, expr, null, true);
      },
  
      'nth-of-type': function(node, expr) {
          return Y.Selector._getNth(node, expr, node.tagName);
      },
       
      'nth-last-of-type': function(node, expr) {
          return Y.Selector._getNth(node, expr, node.tagName, true);
      },
       
      'last-child': function(node) {
          var children = Y.DOM._children(node.parentNode);
          return children[children.length - 1] === node;
      },
  
      'first-of-type': function(node) {
          return Y.DOM._children(node.parentNode, node.tagName)[0] === node;
      },
       
      'last-of-type': function(node) {
          var children = Y.DOM._children(node.parentNode, node.tagName);
          return children[children.length - 1] === node;
      },
       
      'only-child': function(node) {
          var children = Y.DOM._children(node.parentNode);
          return children.length === 1 && children[0] === node;
      },
  
      'only-of-type': function(node) {
          var children = Y.DOM._children(node.parentNode, node.tagName);
          return children.length === 1 && children[0] === node;
      },
  
      'empty': function(node) {
          return node.childNodes.length === 0;
      },
  
      'not': function(node, expr) {
          return !Y.Selector.test(node, expr);
      },
  
      'contains': function(node, expr) {
          var text = node.innerText || node.textContent || '';
          return text.indexOf(expr) > -1;
      },
  
      'checked': function(node) {
          return (node.checked === true || node.selected === true);
      },
  
      enabled: function(node) {
          return (node.disabled !== undefined && !node.disabled);
      },
  
      disabled: function(node) {
          return (node.disabled);
      }
  });
  
  Y.mix(Y.Selector.operators, {
      '^=': '^{val}', // Match starts with value
      '$=': '{val}$', // Match ends with value
      '*=': '{val}' // Match contains value as substring 
  });
  
  Y.Selector.combinators['~'] = {
      axis: 'previousSibling'
  };
  
  
  }, '@VERSION@' ,{requires:['selector-native', 'selector-css2']});
  YUI.add('yui-log', function(Y) {
  
  /**
   * Provides console log capability and exposes a custom event for
   * console implementations. This module is a `core` YUI module, <a href="../classes/YUI.html#method_log">it's documentation is located under the YUI class</a>.
   *
   * @module yui
   * @submodule yui-log
   */
  
  var INSTANCE = Y,
      LOGEVENT = 'yui:log',
      UNDEFINED = 'undefined',
      LEVELS = { debug: 1,
                 info: 1,
                 warn: 1,
                 error: 1 };
  
  /**
   * If the 'debug' config is true, a 'yui:log' event will be
   * dispatched, which the Console widget and anything else
   * can consume.  If the 'useBrowserConsole' config is true, it will
   * write to the browser console if available.  YUI-specific log
   * messages will only be present in the -debug versions of the
   * JS files.  The build system is supposed to remove log statements
   * from the raw and minified versions of the files.
   *
   * @method log
   * @for YUI
   * @param  {String}  msg  The message to log.
   * @param  {String}  cat  The log category for the message.  Default
   *                        categories are "info", "warn", "error", time".
   *                        Custom categories can be used as well. (opt).
   * @param  {String}  src  The source of the the message (opt).
   * @param  {boolean} silent If true, the log event won't fire.
   * @return {YUI}      YUI instance.
   */
  INSTANCE.log = function(msg, cat, src, silent) {
      var bail, excl, incl, m, f,
          Y = INSTANCE,
          c = Y.config,
          publisher = (Y.fire) ? Y : YUI.Env.globalEvents;
      // suppress log message if the config is off or the event stack
      // or the event call stack contains a consumer of the yui:log event
      if (c.debug) {
          // apply source filters
          src = src || "";
          if (typeof src !== "undefined") {
              excl = c.logExclude;
              incl = c.logInclude;
              if (incl && !(src in incl)) {
                  bail = 1;
              } else if (incl && (src in incl)) {
                  bail = !incl[src];
              } else if (excl && (src in excl)) {
                  bail = excl[src];
              }
          }
          if (!bail) {
              if (c.useBrowserConsole) {
                  m = (src) ? src + ': ' + msg : msg;
                  if (Y.Lang.isFunction(c.logFn)) {
                      c.logFn.call(Y, msg, cat, src);
                  } else if (typeof console != UNDEFINED && console.log) {
                      f = (cat && console[cat] && (cat in LEVELS)) ? cat : 'log';
                      console[f](m);
                  } else if (typeof opera != UNDEFINED) {
                      opera.postError(m);
                  }
              }
  
              if (publisher && !silent) {
  
                  if (publisher == Y && (!publisher.getEvent(LOGEVENT))) {
                      publisher.publish(LOGEVENT, {
                          broadcast: 2
                      });
                  }
  
                  publisher.fire(LOGEVENT, {
                      msg: msg,
                      cat: cat,
                      src: src
                  });
              }
          }
      }
  
      return Y;
  };
  
  /**
   * Write a system message.  This message will be preserved in the
   * minified and raw versions of the YUI files, unlike log statements.
   * @method message
   * @for YUI
   * @param  {String}  msg  The message to log.
   * @param  {String}  cat  The log category for the message.  Default
   *                        categories are "info", "warn", "error", time".
   *                        Custom categories can be used as well. (opt).
   * @param  {String}  src  The source of the the message (opt).
   * @param  {boolean} silent If true, the log event won't fire.
   * @return {YUI}      YUI instance.
   */
  INSTANCE.message = function() {
      return INSTANCE.log.apply(INSTANCE, arguments);
  };
  
  
  }, '@VERSION@' ,{requires:['yui-base']});
  YUI.add('dump', function(Y) {
  
  /**
   * Returns a simple string representation of the object or array.
   * Other types of objects will be returned unprocessed.  Arrays
   * are expected to be indexed.  Use object notation for
   * associative arrays.
   *
   * If included, the dump method is added to the YUI instance.
   *
   * @module dump
   */
  
      var L = Y.Lang,
          OBJ = '{...}',
          FUN = 'f(){...}',
          COMMA = ', ',
          ARROW = ' => ',
  
      /**
       * Returns a simple string representation of the object or array.
       * Other types of objects will be returned unprocessed.  Arrays
       * are expected to be indexed.
       *
       * @method dump
       * @param {Object} o The object to dump.
       * @param {Number} d How deep to recurse child objects, default 3.
       * @return {String} the dump result.
       * @for YUI
       */
      dump = function(o, d) {
          var i, len, s = [], type = L.type(o);
  
          // Cast non-objects to string
          // Skip dates because the std toString is what we want
          // Skip HTMLElement-like objects because trying to dump
          // an element will cause an unhandled exception in FF 2.x
          if (!L.isObject(o)) {
              return o + '';
          } else if (type == 'date') {
              return o;
          } else if (o.nodeType && o.tagName) {
              return o.tagName + '#' + o.id;
          } else if (o.document && o.navigator) {
              return 'window';
          } else if (o.location && o.body) {
              return 'document';
          } else if (type == 'function') {
              return FUN;
          }
  
          // dig into child objects the depth specifed. Default 3
          d = (L.isNumber(d)) ? d : 3;
  
          // arrays [1, 2, 3]
          if (type == 'array') {
              s.push('[');
              for (i = 0, len = o.length; i < len; i = i + 1) {
                  if (L.isObject(o[i])) {
                      s.push((d > 0) ? L.dump(o[i], d - 1) : OBJ);
                  } else {
                      s.push(o[i]);
                  }
                  s.push(COMMA);
              }
              if (s.length > 1) {
                  s.pop();
              }
              s.push(']');
          // regexp /foo/
          } else if (type == 'regexp') {
              s.push(o.toString());
          // objects {k1 => v1, k2 => v2}
          } else {
              s.push('{');
              for (i in o) {
                  if (o.hasOwnProperty(i)) {
                      try {
                          s.push(i + ARROW);
                          if (L.isObject(o[i])) {
                              s.push((d > 0) ? L.dump(o[i], d - 1) : OBJ);
                          } else {
                              s.push(o[i]);
                          }
                          s.push(COMMA);
                      } catch (e) {
                          s.push('Error: ' + e.message);
                      }
                  }
              }
              if (s.length > 1) {
                  s.pop();
              }
              s.push('}');
          }
  
          return s.join('');
      };
  
      Y.dump = dump;
      L.dump = dump;
  
  
  
  }, '@VERSION@' ,{requires:['yui-base']});
  YUI.add('transition-timer', function(Y) {
  
  /*
  * The Transition Utility provides an API for creating advanced transitions.
  * @module transition
  */
  
  /*
  * Provides the base Transition class, for animating numeric properties.
  *
  * @module transition
  * @submodule transition-timer
  */
  
  
  var Transition = Y.Transition;
  
  Y.mix(Transition.prototype, {
      _start: function() {
          if (Transition.useNative) {
              this._runNative();
          } else {
              this._runTimer();
          }
      },
  
      _runTimer: function() {
          var anim = this;
          anim._initAttrs();
  
          Transition._running[Y.stamp(anim)] = anim;
          anim._startTime = new Date();
          Transition._startTimer();
      },
  
      _endTimer: function() {
          var anim = this;
          delete Transition._running[Y.stamp(anim)];
          anim._startTime = null;
      },
  
      _runFrame: function() {
          var t = new Date() - this._startTime;
          this._runAttrs(t);
      },
  
      _runAttrs: function(time) {
          var anim = this,
              node = anim._node,
              config = anim._config,
              uid = Y.stamp(node),
              attrs = Transition._nodeAttrs[uid],
              customAttr = Transition.behaviors,
              done = false,
              allDone = false,
              data,
              name,
              attribute,
              setter,
              elapsed,
              delay,
              d,
              t,
              i;
  
          for (name in attrs) {
              if ((attribute = attrs[name]) && attribute.transition === anim) {
                  d = attribute.duration;
                  delay = attribute.delay;
                  elapsed = (time - delay) / 1000;
                  t = time;
                  data = {
                      type: 'propertyEnd',
                      propertyName: name,
                      config: config,
                      elapsedTime: elapsed
                  };
  
                  setter = (i in customAttr && 'set' in customAttr[i]) ?
                          customAttr[i].set : Transition.DEFAULT_SETTER;
  
                  done = (t >= d);
  
                  if (t > d) {
                      t = d;
                  }
  
                  if (!delay || time >= delay) {
                      setter(anim, name, attribute.from, attribute.to, t - delay, d - delay,
                          attribute.easing, attribute.unit); 
  
                      if (done) {
                          delete attrs[name];
                          anim._count--;
  
                          if (config[name] && config[name].on && config[name].on.end) {
                              config[name].on.end.call(Y.one(node), data);
                          }
  
                          //node.fire('transition:propertyEnd', data);
  
                          if (!allDone && anim._count <= 0) {
                              allDone = true;
                              anim._end(elapsed);
                              anim._endTimer();
                          }
                      }
                  }
  
              }
          }
      },
  
      _initAttrs: function() {
          var anim = this,
              customAttr = Transition.behaviors,
              uid = Y.stamp(anim._node),
              attrs = Transition._nodeAttrs[uid],
              attribute,
              duration,
              delay,
              easing,
              val,
              name,
              mTo,
              mFrom,
              unit, begin, end;
  
          for (name in attrs) {
              if ((attribute = attrs[name]) && attribute.transition === anim) {
                  duration = attribute.duration * 1000;
                  delay = attribute.delay * 1000;
                  easing = attribute.easing;
                  val = attribute.value;
  
                  // only allow supported properties
                  if (name in anim._node.style || name in Y.DOM.CUSTOM_STYLES) {
                      begin = (name in customAttr && 'get' in customAttr[name])  ?
                              customAttr[name].get(anim, name) : Transition.DEFAULT_GETTER(anim, name);
  
                      mFrom = Transition.RE_UNITS.exec(begin);
                      mTo = Transition.RE_UNITS.exec(val);
  
                      begin = mFrom ? mFrom[1] : begin;
                      end = mTo ? mTo[1] : val;
                      unit = mTo ? mTo[2] : mFrom ?  mFrom[2] : ''; // one might be zero TODO: mixed units
  
                      if (!unit && Transition.RE_DEFAULT_UNIT.test(name)) {
                          unit = Transition.DEFAULT_UNIT;
                      }
  
                      if (typeof easing === 'string') {
                          if (easing.indexOf('cubic-bezier') > -1) {
                              easing = easing.substring(13, easing.length - 1).split(',');
                          } else if (Transition.easings[easing]) {
                              easing = Transition.easings[easing];
                          }
                      }
  
                      attribute.from = Number(begin);
                      attribute.to = Number(end);
                      attribute.unit = unit;
                      attribute.easing = easing;
                      attribute.duration = duration + delay;
                      attribute.delay = delay;
                  } else {
                      delete attrs[name];
                      anim._count--;
                  }
              }
          }
      },
  
      destroy: function() {
          this.detachAll();
          this._node = null;
      }
  }, true);
  
  Y.mix(Y.Transition, {
      _runtimeAttrs: {},
      /*
       * Regex of properties that should use the default unit.
       *
       * @property RE_DEFAULT_UNIT
       * @static
       */
      RE_DEFAULT_UNIT: /^width|height|top|right|bottom|left|margin.*|padding.*|border.*$/i,
  
      /*
       * The default unit to use with properties that pass the RE_DEFAULT_UNIT test.
       *
       * @property DEFAULT_UNIT
       * @static
       */
      DEFAULT_UNIT: 'px',
  
      /*
       * Time in milliseconds passed to setInterval for frame processing 
       *
       * @property intervalTime
       * @default 20
       * @static
       */
      intervalTime: 20,
  
      /*
       * Bucket for custom getters and setters
       *
       * @property behaviors
       * @static
       */
      behaviors: {
          left: {
              get: function(anim, attr) {
                  return Y.DOM._getAttrOffset(anim._node, attr);
              }
          }
      },
  
      /*
       * The default setter to use when setting object properties.
       *
       * @property DEFAULT_SETTER
       * @static
       */
      DEFAULT_SETTER: function(anim, att, from, to, elapsed, duration, fn, unit) {
          from = Number(from);
          to = Number(to);
  
          var node = anim._node,
              val = Transition.cubicBezier(fn, elapsed / duration);
  
          val = from + val[0] * (to - from);
  
          if (node) {
              if (att in node.style || att in Y.DOM.CUSTOM_STYLES) {
                  unit = unit || '';
                  Y.DOM.setStyle(node, att, val + unit);
              }
          } else {
              anim._end();
          }
      },
  
      /*
       * The default getter to use when getting object properties.
       *
       * @property DEFAULT_GETTER
       * @static
       */
      DEFAULT_GETTER: function(anim, att) {
          var node = anim._node,
              val = '';
  
          if (att in node.style || att in Y.DOM.CUSTOM_STYLES) {
              val = Y.DOM.getComputedStyle(node, att);
          }
  
          return val;
      },
  
      _startTimer: function() {
          if (!Transition._timer) {
              Transition._timer = setInterval(Transition._runFrame, Transition.intervalTime);
          }
      },
  
      _stopTimer: function() {
          clearInterval(Transition._timer);
          Transition._timer = null;
      },
  
      /*
       * Called per Interval to handle each animation frame.
       * @method _runFrame
       * @private
       * @static
       */    
      _runFrame: function() {
          var done = true,
              anim;
          for (anim in Transition._running) {
              if (Transition._running[anim]._runFrame) {
                  done = false;
                  Transition._running[anim]._runFrame();
              }
          }
  
          if (done) {
              Transition._stopTimer();
          }
      },
  
      cubicBezier: function(p, t) {
          var x0 = 0,
              y0 = 0,
              x1 = p[0],
              y1 = p[1],
              x2 = p[2],
              y2 = p[3],
              x3 = 1,
              y3 = 0,
  
              A = x3 - 3 * x2 + 3 * x1 - x0,
              B = 3 * x2 - 6 * x1 + 3 * x0,
              C = 3 * x1 - 3 * x0,
              D = x0,
              E = y3 - 3 * y2 + 3 * y1 - y0,
              F = 3 * y2 - 6 * y1 + 3 * y0,
              G = 3 * y1 - 3 * y0,
              H = y0,
  
              x = (((A*t) + B)*t + C)*t + D,
              y = (((E*t) + F)*t + G)*t + H;
  
          return [x, y];
      },
  
      easings: {
          ease: [0.25, 0, 1, 0.25],
          linear: [0, 0, 1, 1],
          'ease-in': [0.42, 0, 1, 1],
          'ease-out': [0, 0, 0.58, 1],
          'ease-in-out': [0.42, 0, 0.58, 1]
      },
  
      _running: {},
      _timer: null,
  
      RE_UNITS: /^(-?\d*\.?\d*){1}(em|ex|px|in|cm|mm|pt|pc|%)*$/
  }, true); 
  
  Transition.behaviors.top = Transition.behaviors.bottom = Transition.behaviors.right = Transition.behaviors.left;
  
  Y.Transition = Transition;
  
  
  }, '@VERSION@' ,{requires:['transition']});
  YUI.add('simpleyui', function(Y) {
  
  // empty
  
  
  
  }, '@VERSION@' ,{use:['yui','oop','dom','event-custom-base','event-base','pluginhost','node','event-delegate','io-base','json-parse','transition','selector-css3','dom-style-ie','querystring-stringify-simple']});
  var Y = YUI().use('*');
  