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
   * @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();
   *
   * @class YUI
   * @constructor
   * @global
   * @uses EventTarget
   * @param o* {object} 0..n optional configuration objects.  these values
   * are store in Y.config.  See config 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.
              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.
              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/',
          DOC_LABEL = 'yui3-js-enabled',
          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.ignoreRegistered = false;
                  loader.onEnd = null;
                  loader.data = null;
                  loader.required = [];
                  loader.loadType = null;
              } else {
                  loader = new Y.Loader(Y.config);
                  Y.Env._loader = loader;
              }
  
              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.2.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} 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,
              rls = config.rls,
              loader = this.Env._loader;
  
          for (name in o) {
              if (o.hasOwnProperty(name)) {
                  attr = o[name];
                  if (mods && name == 'modules') {
                      clobber(mods, attr);
                  } else if (groups && name == 'groups') {
                      clobber(groups, attr);
                  } else if (rls && name == 'rls') {
                      clobber(rls, attr);
                  } else if (name == 'win') {
                      config[name] = attr.contentWindow || attr;
                      config.doc = config[name].document;
                  } else if (name == '_yuid') {
                      // preserve the guid
                  } else {
                      config[name] = attr;
                  }
              }
          }
  
          if (loader) {
              loader._config(o);
          }
      },
  
      _config: function(o) {
          this.applyConfig(o);
      },
  
      /**
       * Initialize this YUI instance
       * @private
       */
      _init: function() {
          var filter,
              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 = {
                  mods: {}, // flat module map
                  versions: {}, // version module map
                  base: BASE,
                  cdn: BASE + VERSION + '/build/',
                  // bootstrapped: false,
                  _idx: 0,
                  _used: {},
                  _attached: {},
                  _yidx: 0,
                  _uidx: 0,
                  _guidp: 'y',
                  _loaded: {},
                  serviced: {},
                  getBase: G_ENV && G_ENV.getBase ||
  
      function(srcPattern, comboPattern) {
          var b, nodes, i, src, match;
          // get from querystring
          nodes = (doc && doc.getElementsByTagName('script')) || [];
          for (i = 0; i < nodes.length; i = i + 1) {
              src = nodes[i].src;
              if (src) {
  
                  match = src.match(srcPattern);
                  b = match && match[1];
                  if (b) {
                      // this is to set up the path to the loader.  The file
                      // filter for loader should match the yui include.
                      filter = match[2];
  
                      if (filter) {
                          match = filter.indexOf('js');
  
                          if (match > -1) {
                              filter = filter.substr(0, match);
                          }
                      }
  
                      // extract correct path for mixed combo urls
                      // http://yuilibrary.com/projects/yui3/ticket/2528423
                      match = src.match(comboPattern);
                      if (match && match[3]) {
                          b = match[1] + match[3];
                      }
  
                      break;
                  }
              }
          }
  
          // use CDN default
          return b || Env.cdn;
      }
              };
  
              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, '_');
              } 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 || {
              win: win,
              doc: doc,
              debug: true,
              useBrowserConsole: true,
              throwFail: true,
              bootstrap: true,
              fetchCSS: true
          };
  
          Y.config.base = YUI.config.base ||
              Y.Env.getBase(/^(.*)yui\/yui([\.\-].*)js(\?.*)?$/,
                            /^(.*\?)(.*\&)(.*)yui\/yui[\.\-].*js(\?.*)?$/);
  
          if (!filter || (!('-min.-debug.').indexOf(filter))) {
              filter = '-min.';
          }
  
          Y.config.loaderPath = YUI.config.loaderPath ||
              'loader/loader' + (filter || '-min.') + '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',
                                          'rls',
                                          'intl-base',
                                          'loader',
                                          'yui-log',
                                          'yui-later',
                                          'yui-throttle'];
  
          for (i = 0; i < extras.length; i++) {
              if (mods[extras[i]]) {
                  core.push(extras[i]);
              }
          }
  
          Y._attach(['yui-base']);
          Y._attach(core);
  
          // Y.log(Y.id + ' initialized', 'info', 'yui');
      },
  
      /**
       * 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.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 version {string} version string.
       * @param details {object} optional config data:
       * requires: features that must be present before this module can be
       * attached.
       * optional: 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.
       * use: 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.
       *
       */
      add: function(name, fn, version, details) {
          details = details || {};
          var env = YUI.Env,
              mod = {
                  name: name,
                  fn: fn,
                  version: version,
                  details: details
              },
              loader,
              i, versions = env.versions;
  
          env.mods[name] = mod;
          versions[version] = versions[version] || {};
          versions[version][name] = mod;
  
          for (i in instances) {
              if (instances.hasOwnProperty(i)) {
                  loader = instances[i].Env._loader;
                  if (loader) {
                      if (!loader.moduleInfo[name]) {
                          loader.addModule(details, name);
                      }
                  }
              }
          }
  
          return this;
      },
  
      /**
       * Executes the function associated with each required
       * module, binding the module to the YUI instance.
       * @method _attach
       * @private
       */
      _attach: function(r, fromLoader) {
          var i, name, mod, details, req, use, after,
              mods = YUI.Env.mods,
              Y = this, j,
              done = Y.Env._attached,
              len = r.length, loader;
  
          // Y.log('attaching: ' + r, 'info', 'yui');
  
          for (i = 0; i < len; i++) {
              if (!done[r[i]]) {
                  name = r[i];
                  mod = mods[name];
                  if (!mod) {
                      loader = Y.Env._loader;
  
                      // Y.log('no js def for: ' + name, 'info', 'yui');
  
                      if (!loader || !loader.moduleInfo[name]) {
                          Y.message('NOT loaded: ' + name, 'warn', 'yui');
                      }
                  } else {
                      done[name] = true;
                      details = mod.details;
                      req = details.requires;
                      use = details.use;
                      after = details.after;
  
                      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)) {
                                      return false;
                                  }
                                  break;
                              }
                          }
                      }
  
  
                      if (use) {
                          for (j = 0; j < use.length; j++) {
                              if (!done[use[j]]) {
                                  if (!Y._attach(use)) {
                                      return false;
                                  }
                                  break;
                              }
                          }
                      }
  
                      if (mod.fn) {
                          try {
                              mod.fn(Y, name);
                          } catch (e) {
                              Y.error('Attach error: ' + name, e, name);
                              return false;
                          }
                      }
  
                  }
              }
          }
  
          return true;
      },
  
      /**
       * 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.
       *
       * @param modules* {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.
       * <code>
       * // loads and attaches drag and drop and its dependencies
       * YUI().use('dd', function(Y) &#123;&#125);
       * // attaches all modules that are available on the page
       * YUI().use('*', function(Y) &#123;&#125);
       * // intrinsic YUI gallery support (since 3.1.0)
       * YUI().use('gallery-yql', function(Y) &#123;&#125);
       * // intrinsic YUI 2in3 support (since 3.1.0)
       * YUI().use('yui2-datatable', function(Y) &#123;&#125);.
       * </code>
       *
       * @return {YUI} the YUI instance.
       */
      use: function() {
          var args = SLICE.call(arguments, 0),
              callback = args[args.length - 1],
              Y = this,
              key;
  
          // The last argument supplied to use can be a load complete callback
          if (Y.Lang.isFunction(callback)) {
              args.pop();
          } else {
              callback = null;
          }
  
          if (Y._loading) {
              Y._useQueue = Y._useQueue || new Y.Queue();
              Y._useQueue.add([args, callback]);
          } else {
              key = args.join();
  
              if (Y.Env.serviced[key]) {
                  Y.log('already provisioned: ' + key, 'info', 'yui');
                  Y._notify(callback, ALREADY_DONE, args);
              } else {
                  Y._use(args, function(Y, response) {
                      Y.log('caching request: ' + key, 'info', 'yui');
                      Y.Env.serviced[key] = true;
                      Y._notify(callback, response, args);
                  });
              }
          }
  
          return Y;
      },
  
      _notify: function(callback, response, args) {
          if (callback) {
              try {
                  callback(this, response);
              } catch (e) {
                  this.error('use callback error', e, args);
              }
          }
      },
  
      _use: function(args, callback) {
  
          if (!this.Array) {
              this._attach(['yui-base']);
          }
  
          var len, loader, handleBoot,
              Y = this,
              G_ENV = YUI.Env,
              mods = G_ENV.mods,
              Env = Y.Env,
              used = Env._used,
              queue = G_ENV._loaderQueue,
              firstArg = args[0],
              YArray = Y.Array,
              config = Y.config,
              boot = config.bootstrap,
              missing = [],
              r = [],
              ret = true,
              fetchCSS = config.fetchCSS,
              process = function(names, skip) {
  
                  if (!names.length) {
                      return;
                  }
  
                  YArray.each(names, function(name) {
  
                      // add this module to full list of things to attach
                      if (!skip) {
                          r.push(name);
                      }
  
                      // only attach a module once
                      if (used[name]) {
                          return;
                      }
  
                      var m = mods[name], req, use;
  
                      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 (missing.sort().join() ==
                                  origMissing.sort().join()) {
                              redo = false;
                          }
                      }
                  }
  
                  if (redo && data) {
                      Y._loading = false;
                      Y._use(args, function() {
                          Y.log('Nested use callback: ' + data, 'info', 'yui');
                          if (Y._attach(data)) {
                              Y._notify(callback, response, data);
                          }
                      });
                  } else {
                      if (data) {
                          // Y.log('attaching from loader: ' + data, 'info', 'yui');
                          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());
                  }
  
              };
  
  // Y.log(Y.id + ': use called: ' + a + ' :: ' + callback, 'info', 'yui');
  
          // YUI().use('*'); // bind everything available
          if (firstArg === '*') {
              ret = Y._attach(Y.Object.keys(mods));
              if (ret) {
                  handleLoader();
              }
              return Y;
          }
  
          // Y.log('before loader requirements: ' + args, 'info', 'yui');
  
          // 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.calculate(null, (fetchCSS) ? null : 'js');
              args = loader.sorted;
          }
  
          // process each requirement and any additional requirements
          // the module metadata specifies
          process(args);
  
          len = missing.length;
  
          if (len) {
              missing = Y.Object.keys(YArray.hash(missing));
              len = missing.length;
  Y.log('Modules missing: ' + missing + ', ' + missing.length, 'info', 'yui');
          }
  
          // dynamic load
          if (boot && len && Y.Loader) {
  // Y.log('Using loader to fetch missing deps: ' + missing, 'info', 'yui');
              Y.log('Using Loader', 'info', 'yui');
              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');
              // loader.partial(missing, (fetchCSS) ? null : 'js');
  
          } else if (len && Y.config.use_rls) {
  
              // server side loader service
              Y.Get.script(Y._rls(args), {
                  onEnd: function(o) {
                      handleLoader(o);
                  },
                  data: args
              });
  
          } else if (boot && len && Y.Get && !Env.bootstrapped) {
  
              Y._loading = true;
  
              handleBoot = function() {
                  Y._loading = false;
                  queue.running = false;
                  Env.bootstrapped = true;
                  if (Y._attach(['loader'])) {
                      Y._use(args, callback);
                  }
              };
  
              if (G_ENV._bootstrapping) {
  Y.log('Waiting for loader', 'info', 'yui');
                  queue.add(handleBoot);
              } else {
                  G_ENV._bootstrapping = true;
  Y.log('Fetching loader: ' + config.base + config.loaderPath, 'info', 'yui');
                  Y.Get.script(config.base + config.loaderPath, {
                      onEnd: handleBoot
                  });
              }
  
          } else {
              Y.log('Attaching available dependencies: ' + args, 'info', 'yui');
              ret = Y._attach(args);
              if (ret) {
                  handleLoader();
              }
          }
  
          return Y;
      },
  
  
      /**
       * Returns the namespace specified and creates it if it doesn't exist
       * <pre>
       * YUI.namespace("property.package");
       * YUI.namespace("YAHOO.property.package");
       * </pre>
       * Either of the above would create YUI.property, then
       * YUI.property.package (YAHOO is scrubbed out, this is
       * to remain compatible with YUI2)
       *
       * Be careful when naming packages. Reserved words may work in some browsers
       * and not others. For instance, the following will fail in Safari:
       * <pre>
       * YUI.namespace("really.long.nested.namespace");
       * </pre>
       * This fails because "long" is a future reserved word in ECMAScript
       *
       * @method namespace
       * @param  {string*} arguments 1-n namespaces to create.
       * @return {object}  A reference to the last namespace object created.
       */
      namespace: function() {
          var a = arguments, o = this, i = 0, j, d, arg;
          for (; i < a.length; i++) {
              // d = ('' + a[i]).split('.');
              arg = a[i];
              if (arg.indexOf(PERIOD)) {
                  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] || {};
              }
          }
          return o;
      },
  
      // this is replaced if the log module is included
      log: NOOP,
      message: NOOP,
  
      /**
       * Report an error.  The reporting mechanism is controled by
       * the 'throwFail' configuration attribute.  If throwFail is
       * not specified, the message is written to the Logger, otherwise
       * a JS error is thrown
       * @method error
       * @param msg {string} the error message.
       * @param e {Error} Optional JS error that was caught.  If supplied
       * and throwFail is specified, this error will be re-thrown.
       * @return {YUI} this YUI instance.
       */
      error: function(msg, e) {
  
          var Y = this, ret;
  
          if (Y.config.errorFn) {
              ret = Y.config.errorFn.apply(Y, arguments);
          }
  
          if (Y.config.throwFail && !ret) {
              throw (e || new Error(msg));
          } else {
              Y.message(msg, 'error'); // 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 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
       * @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];
          }
      }
  
      // 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
   */
  
  /**
   * 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).
   *
   * @property core
   * @type string[]
   */
  
  /**
   * 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 remove 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:
   * <pre>
   *  myFilter: &#123;
   *      'searchExp': "-min\\.js",
   *      'replaceStr': "-debug.js"
   *  &#125;
   * </pre>
   *
   * 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.
   * <code>
   * modules: {
   * &nbsp; mymod1: {
   * &nbsp;   requires: ['node'],
   * &nbsp;   fullpath: 'http://myserver.mydomain.com/mymod1/mymod1.js'
   * &nbsp; },
   * &nbsp; mymod2: {
   * &nbsp;   requires: ['mymod1'],
   * &nbsp;   fullpath: 'http://myserver.mydomain.com/mymod2/mymod2.js'
   * &nbsp; }
   * }
   * </code>
   *
   * @property modules
   * @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.  @see
   * @see modules for the details about the modules part of the
   * group definition.
   * <code>
   * &nbsp; groups: {
   * &nbsp;     yui2: {
   * &nbsp;         // specify whether or not this group has a combo service
   * &nbsp;         combine: true,
   * &nbsp;
   * &nbsp;         // the base path for non-combo paths
   * &nbsp;         base: 'http://yui.yahooapis.com/2.8.0r4/build/',
   * &nbsp;
   * &nbsp;         // the path to the combo service
   * &nbsp;         comboBase: 'http://yui.yahooapis.com/combo?',
   * &nbsp;
   * &nbsp;         // a fragment to prepend to the path attribute when
   * &nbsp;         // when building combo urls
   * &nbsp;         root: '2.8.0r4/build/',
   * &nbsp;
   * &nbsp;         // the module definitions
   * &nbsp;         modules:  {
   * &nbsp;             yui2_yde: {
   * &nbsp;                 path: "yahoo-dom-event/yahoo-dom-event.js"
   * &nbsp;             },
   * &nbsp;             yui2_anim: {
   * &nbsp;                 path: "animation/animation.js",
   * &nbsp;                 requires: ['yui2_yde']
   * &nbsp;             }
   * &nbsp;         }
   * &nbsp;     }
   * &nbsp; }
   * </code>
   * @property modules
   * @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.8.1
   */
  
  /**
   * 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 1
   */
  
  /**
   * 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.
   *
   * @since 3.2.0
   * @property errorFn
   * @type Function
   */
  
  /**
   * The parameter defaults for the remote loader service.
   * Requires the rls submodule.  The properties that are
   * supported:
   * <pre>
   * m: comma separated list of module requirements.  This
   *    must be the param name even for custom implemetations.
   * v: the version of YUI to load.  Defaults to the version
   *    of YUI that is being used.
   * gv: the version of the gallery to load (@see the gallery config)
   * env: comma separated list of modules already on the page.
   *      this must be the param name even for custom implemetations.
   * lang: the languages supported on the page (@see the lang config)
   * '2in3v':  the version of the 2in3 wrapper to use (@see the 2in3 config).
   * '2v': the version of yui2 to use in the yui 2in3 wrappers
   *       (@see the yui2 config)
   * filt: a filter def to apply to the urls (@see the filter config).
   * filts: a list of custom filters to apply per module
   *        (@see the filters config).
   * tests: this is a map of conditional module test function id keys
   * with the values of 1 if the test passes, 0 if not.  This must be
   * the name of the querystring param in custom templates.
   *</pre>
   *
   * @since 3.2.0
   * @property rls
   */
  
  /**
   * The base path to the remote loader service
   *
   * @since 3.2.0
   * @property rls_base
   */
  
  /**
   * The template to use for building the querystring portion
   * of the remote loader service url.  The default is determined
   * by the rls config -- each property that has a value will be
   * represented.
   *
   * ex: m={m}&v={v}&env={env}&lang={lang}&filt={filt}&tests={tests}
   *
   *
   * @since 3.2.0
   * @property rls_tmpl
   */
  
  /**
   * Configure the instance to use a remote loader service instead of
   * the client loader.
   *
   * @since 3.2.0
   * @property use_rls
   */
  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 the language utilites and extensions used by the library
   * @class Lang
   * @static
   */
  Y.Lang = Y.Lang || {};
  
  var L = Y.Lang,
  
  ARRAY = 'array',
  BOOLEAN = 'boolean',
  DATE = 'date',
  ERROR = 'error',
  FUNCTION = 'function',
  NUMBER = 'number',
  NULL = 'null',
  OBJECT = 'object',
  REGEX = 'regexp',
  STRING = 'string',
  STRING_PROTO = String.prototype,
  TOSTRING = Object.prototype.toString,
  UNDEFINED = 'undefined',
  
  TYPES = {
      'undefined' : UNDEFINED,
      'number' : NUMBER,
      'boolean' : BOOLEAN,
      'string' : STRING,
      '[object Function]' : FUNCTION,
      '[object RegExp]' : REGEX,
      '[object Array]' : ARRAY,
      '[object Date]' : DATE,
      '[object Error]' : ERROR
  },
  
  TRIMREGEX = /^\s+|\s+$/g,
  EMPTYSTRING = '',
  SUBREGEX = /\{\s*([^\|\}]+?)\s*(?:\|([^\}]*))?\s*\}/g;
  
  /**
   * Determines whether or not the provided item is an array.
   * Returns false for array-like collections such as the
   * function arguments collection or HTMLElement collection
   * will return false.  Use <code>Y.Array.test</code> if you
   * want to test for an array-like collection.
   * @method isArray
   * @static
   * @param o The object to test.
   * @return {boolean} true if o is an array.
   */
  L.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;
  };
  
  /**
   * <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 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 o instanceof Date;
      return L.type(o) === DATE && o.toString() !== 'Invalid Date' && !isNaN(o);
  };
  
  /**
   * 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.
   */
  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;
  };
  
  /**
   * 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, EMPTYSTRING);
      } 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+$/, '');
  };
  
  /**
   * 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:
          case UNDEFINED:
              return false;
          default:
              return !!(t);
      }
  };
  
  /**
   * <p>
   * Returns a string representing the type of the item passed in.
   * </p>
   *
   * <p>
   * Known issues:
   * </p>
   *
   * <ul>
   *   <li>
   *     <code>typeof HTMLElementCollection</code> returns function in Safari, but
   *     <code>Y.type()</code> reports object, which could be a good thing --
   *     but it actually caused the logic in <code>Y.Lang.isObject</code> to fail.
   *   </li>
   * </ul>
   *
   * @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);
  };
  
  /**
   * 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])) ? o[key] : match;
      }) : s);
  };
  
  /**
   * Returns the current time in milliseconds.
   * @method now
   * @return {int} the current date
   * @since 3.3.0
   */
  L.now = Date.now || function () {
    return new Date().getTime();
  };
  
  /**
   * 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 Native = Array.prototype, LENGTH = 'length',
  
  /**
   * Adds the following array utilities to the YUI instance.  Additional
   * array helpers can be found in the collection component.
   * @class Array
   */
  
  /**
   * Y.Array(o) returns an array:
   * - Arrays are return unmodified unless the start position is specified.
   * - "Array-like" collections (@see Array.test) are converted to arrays
   * - For everything else, a new array is created with the input as the sole
   *   item.
   * - The start position is used if the input is or is like an array to return
   *   a subset of the collection.
   *
   *   @todo this will not automatically convert elements that are also
   *   collections such as forms and selects.  Passing true as the third
   *   param will force a conversion.
   *
   * @method ()
   * @static
   *   @param {object} o the item to arrayify.
   *   @param {int} startIdx if an array or array-like, this is the start index.
   *   @param {boolean} arraylike if true, it forces the array-like fork.  This
   *   can be used to avoid multiple Array.test calls.
   *   @return {Array} the resulting array.
   */
  YArray = function(o, startIdx, arraylike) {
      var t = (arraylike) ? 2 : YArray.test(o),
          l, a, start = startIdx || 0;
  
      if (t) {
          // IE errors when trying to slice HTMLElement collections
          try {
              return Native.slice.call(o, start);
          } catch (e) {
              a = [];
              l = o.length;
              for (; start < l; start++) {
                  a.push(o[start]);
              }
              return a;
          }
      } else {
          return [o];
      }
  };
  
  Y.Array = YArray;
  
  /**
   * Evaluates the input to determine if it is an array, array-like, or
   * something else.  This is used to handle the arguments collection
   * available within functions, and HTMLElement collections
   *
   * @method test
   * @static
   *
   * @todo current implementation (intenionally) will not implicitly
   * handle html elements that are array-like (forms, selects, etc).
   *
   * @param {object} o the object to test.
   *
   * @return {int} a number indicating the results:
   * 0: Not an array or an array-like collection
   * 1: A real array.
   * 2: array-like collection.
   */
  YArray.test = function(o) {
      var r = 0;
      if (Y.Lang.isObject(o)) {
          if (Y.Lang.isArray(o)) {
              r = 1;
          } else {
              try {
                  // indexed, but no tagName (element) or alert (window),
                  // or functions without apply/call (Safari
                  // HTMLElementCollection bug).
                  if ((LENGTH in o) && !o.tagName && !o.alert && !o.apply) {
                      r = 2;
                  }
  
              } catch (e) {}
          }
      }
      return r;
  };
  
  /**
   * Executes the supplied function on each item in the array.
   * @method each
   * @param {Array} a the array to iterate.
   * @param {Function} f the function to execute on each item.  The
   * function receives three arguments: the value, the index, the full array.
   * @param {object} o Optional context object.
   * @static
   * @return {YUI} the YUI instance.
   */
  YArray.each = (Native.forEach) ?
      function(a, f, o) {
          Native.forEach.call(a || [], f, o || Y);
          return Y;
      } :
      function(a, f, o) {
          var l = (a && a.length) || 0, i;
          for (i = 0; i < l; i = i + 1) {
              f.call(o || Y, a[i], i, a);
          }
          return Y;
      };
  
  /**
   * Returns an object using the first array as keys, and
   * the second as values.  If the second array is not
   * provided the value is set to true for each.
   * @method hash
   * @static
   * @param {Array} k keyset.
   * @param {Array} v optional valueset.
   * @return {object} the hash.
   */
  YArray.hash = function(k, v) {
      var o = {}, l = k.length, vl = v && v.length, i;
      for (i = 0; i < l; i = i + 1) {
          o[k[i]] = (vl && vl > i) ? v[i] : true;
      }
  
      return o;
  };
  
  /**
   * Returns the index of the first item in the array
   * that contains the specified value, -1 if the
   * value isn't found.
   * @method indexOf
   * @static
   * @param {Array} a the array to search.
   * @param {any} val the value to search for.
   * @return {int} the index of the item that contains the value or -1.
   */
  YArray.indexOf = (Native.indexOf) ?
      function(a, val) {
          return Native.indexOf.call(a, val);
      } :
      function(a, val) {
          for (var i = 0; i < a.length; i = i + 1) {
              if (a[i] === val) {
                  return i;
              }
          }
  
          return -1;
      };
  
  /**
   * Numeric sort convenience function.
   * Y.ArrayAssert.itemsAreEqual([1,2,3], [3,1,2].sort(Y.Array.numericSort));
   * @method numericSort
   * @static
   * @param {number} a a number.
   * @param {number} b a number.
   */
  YArray.numericSort = function(a, b) {
      return (a - b);
  };
  
  /**
   * Executes the supplied function on each item in the array.
   * Returning true from the processing function will stop the
   * processing of the remaining items.
   * @method some
   * @param {Array} a the array to iterate.
   * @param {Function} f the function to execute on each item. The function
   * receives three arguments: the value, the index, the full array.
   * @param {object} o Optional context object.
   * @static
   * @return {boolean} true if the function returns true on
   * any of the items in the array.
   */
  YArray.some = (Native.some) ?
      function(a, f, o) {
          return Native.some.call(a, f, o);
      } :
      function(a, f, o) {
          var l = a.length, i;
          for (i = 0; i < l; i = i + 1) {
              if (f.call(o, a[i], i, a)) {
                  return true;
              }
          }
          return false;
      };
  
  /**
   * 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 = '__',
  
  /*
   * IE will not enumerate native functions in a derived object even if the
   * function was overridden.  This is a workaround for specific functions
   * we care about on the Object prototype.
   * @property _iefix
   * @for YUI
   * @param {Function} r  the object to receive the augmentation
   * @param {Function} s  the object that supplies the properties to augment
   * @private
   */
  _iefix = function(r, s) {
      var fn = s.toString;
      if (Y.Lang.isFunction(fn) && fn != Object.prototype.toString) {
          r.toString = fn;
      }
  };
  
  
  /**
   * 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
   * @for YUI
   * @param arguments {Object*} the objects to merge.
   * @return {object} the new merged object.
   */
  Y.merge = function() {
      var a = arguments, o = {}, i, l = a.length;
      for (i = 0; i < l; i = i + 1) {
          Y.mix(o, a[i], true);
      }
      return o;
  };
  
  /**
   * Applies the supplier's properties to the receiver.  By default
   * all prototype and static propertes on the supplier are applied
   * to the corresponding spot on the receiver.  By default all
   * properties are applied, and a property that is already on the
   * reciever will not be overwritten.  The default behavior can
   * be modified by supplying the appropriate parameters.
   *
   * @todo add constants for the modes
   *
   * @method mix
   * @param {Function} r  the object to receive the augmentation.
   * @param {Function} s  the object that supplies the properties to augment.
   * @param ov {boolean} if true, properties already on the receiver
   * will be overwritten if found on the supplier.
   * @param wl {string[]} a whitelist.  If supplied, only properties in
   * this list will be applied to the receiver.
   * @param {int} mode what should be copies, and to where
   *        default(0): object to object
   *        1: prototype to prototype (old augment)
   *        2: prototype to prototype and object props (new augment)
   *        3: prototype to object
   *        4: object to prototype.
   * @param merge {boolean/int} merge objects instead of overwriting/ignoring.
   * A value of 2 will skip array merge
   * Used by Y.aggregate.
   * @return {object} the augmented object.
   */
  Y.mix = function(r, s, ov, wl, mode, merge) {
  
      if (!s || !r) {
          return r || Y;
      }
  
      if (mode) {
          switch (mode) {
              case 1: // proto to proto
                  return Y.mix(r.prototype, s.prototype, ov, wl, 0, merge);
              case 2: // object to object and proto to proto
                  Y.mix(r.prototype, s.prototype, ov, wl, 0, merge);
                  break; // pass through
              case 3: // proto to static
                  return Y.mix(r, s.prototype, ov, wl, 0, merge);
              case 4: // static to proto
                  return Y.mix(r.prototype, s, ov, wl, 0, merge);
              default:  // object to object is what happens below
          }
      }
  
      // Maybe don't even need this wl && wl.length check anymore??
      var i, l, p, type;
  
      if (wl && wl.length) {
          for (i = 0, l = wl.length; i < l; ++i) {
              p = wl[i];
              type = Y.Lang.type(r[p]);
              if (s.hasOwnProperty(p)) {
                  if (merge && type == 'object') {
                      Y.mix(r[p], s[p]);
                  } else if (ov || !(p in r)) {
                      r[p] = s[p];
                  }
              }
          }
      } else {
          for (i in s) {
              // if (s.hasOwnProperty(i) && !(i in FROZEN)) {
              if (s.hasOwnProperty(i)) {
                  // check white list if it was supplied
                  // if the receiver has this property, it is an object,
                  // and merge is specified, merge the two objects.
                  if (merge && Y.Lang.isObject(r[i], true)) {
                      Y.mix(r[i], s[i], ov, wl, 0, true); // recursive
                  // otherwise apply the property only if overwrite
                  // is specified or the receiver doesn't have one.
                  } else if (ov || !(i in r)) {
                      r[i] = s[i];
                  }
                  // if merge is specified and the receiver is an array,
                  // append the array item
                  // } else if (arr) {
                      // r.push(s[i]);
                  // }
              }
          }
  
          if (Y.UA.ie) {
              _iefix(r, s);
          }
      }
  
      return r;
  };
  
  /**
   * Returns a wrapper for a function which caches the
   * return value of that function, keyed off of the combined
   * argument values.
   * @method cached
   * @param source {function} the function to memoize.
   * @param cache an optional cache seed.
   * @param refetch if supplied, this value is tested against the cached
   * value.  If the values are equal, the wrapped function is executed again.
   * @return {Function} the wrapped function.
   */
  Y.cached = function(source, cache, refetch) {
      cache = cache || {};
  
      return function(arg1) {
  
          var k = (arguments.length > 1) ?
              Array.prototype.join.call(arguments, CACHED_DELIMITER) : arg1;
  
          if (!(k in cache) || (refetch && cache[k] == refetch)) {
              cache[k] = source.apply(source, arguments);
          }
  
          return cache[k];
      };
  
  };
  
  /**
   * 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 the following Object utilities to the YUI instance
   * @class Object
   */
  
  /**
   * Y.Object(o) returns a new object based upon the supplied object.
   * @method ()
   * @static
   * @param o the supplier object.
   * @return {Object} the new object.
   */
  var F = function() {},
  
  O = Object.create || function(o) {
      F.prototype = o;
      return new F();
  },
  
  
  owns = function(o, k) {
      return o && o.hasOwnProperty && o.hasOwnProperty(k);
      // return Object.prototype.hasOwnProperty.call(o, k);
  },
  
  UNDEF,
  
  /**
   * Extracts the keys, values, or size from an object
   *
   * @method _extract
   * @param o the object.
   * @param what what to extract (0: keys, 1: values, 2: size).
   * @return {boolean|Array} the extracted info.
   * @static
   * @private
   */
  _extract = function(o, what) {
      var count = (what === 2), out = (count) ? 0 : [], i;
  
      for (i in o) {
          if (owns(o, i)) {
              if (count) {
                  out++;
              } else {
                  out.push((what) ? o[i] : i);
              }
          }
      }
  
      return out;
  };
  
  Y.Object = O;
  
  /**
   * Returns an array containing the object's keys
   * @method keys
   * @static
   * @param o an object.
   * @return {string[]} the keys.
   */
  O.keys = Object.keys || function(o) {
      return _extract(o);
  };
  
  /**
   * Returns an array containing the object's values
   * @method values
   * @static
   * @param o an object.
   * @return {Array} the values.
   */
  O.values = Object.values || function(o) {
      return _extract(o, 1);
  };
  
  /**
   * Returns the size of an object
   * @method size
   * @static
   * @param o an object.
   * @return {int} the size.
   */
  O.size = Object.size || function(o) {
      return _extract(o, 2);
  };
  
  /**
   * Returns true if the object contains a given key
   * @method hasKey
   * @static
   * @param o an object.
   * @param k the key to query.
   * @return {boolean} true if the object contains the key.
   */
  O.hasKey = owns;
  /**
   * Returns true if the object contains a given value
   * @method hasValue
   * @static
   * @param o an object.
   * @param v the value to query.
   * @return {boolean} true if the object contains the value.
   */
  O.hasValue = function(o, v) {
      return (Y.Array.indexOf(O.values(o), v) > -1);
  };
  
  /**
   * Determines whether or not the property was added
   * to the object instance.  Returns false if the property is not present
   * in the object, or was inherited from the prototype.
   *
   * @method owns
   * @static
   * @param o {any} The object being testing.
   * @param p {string} the property to look for.
   * @return {boolean} true if the object has the property on the instance.
   */
  O.owns = owns;
  
  /**
   * Executes a function on each item. The function
   * receives the value, the key, and the object
   * as parameters (in that order).
   * @method each
   * @static
   * @param o the object to iterate.
   * @param f {Function} the function to execute on each item. The function
   * receives three arguments: the value, the the key, the full object.
   * @param c the execution context.
   * @param proto {boolean} include proto.
   * @return {YUI} the YUI instance.
   */
  O.each = function(o, f, c, proto) {
      var s = c || Y, i;
  
      for (i in o) {
          if (proto || owns(o, i)) {
              f.call(s, o[i], i, o);
          }
      }
      return Y;
  };
  
  /**
   * Executes a function on each item, but halts if the
   * function returns true.  The function
   * receives the value, the key, and the object
   * as paramters (in that order).
   * @method some
   * @static
   * @param o the object to iterate.
   * @param f {Function} the function to execute on each item. The function
   * receives three arguments: the value, the the key, the full object.
   * @param c the execution context.
   * @param proto {boolean} include proto.
   * @return {boolean} true if any execution of the function returns true,
   * false otherwise.
   */
  O.some = function(o, f, c, proto) {
      var s = c || Y, i;
  
      for (i in o) {
          if (proto || owns(o, i)) {
              if (f.call(s, o[i], i, o)) {
                  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 (!Y.Lang.isObject(o)) {
          return UNDEF;
      }
  
      var i,
          p = Y.Array(path),
          l = p.length;
  
      for (i = 0; o !== UNDEF && 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 !== UNDEF && i < leafIdx; i++) {
              ref = ref[p[i]];
          }
  
          if (ref !== UNDEF) {
              ref[p[i]] = val;
          } else {
              return UNDEF;
          }
      }
  
      return o;
  };
  
  /**
   * Returns true if the object has no properties of its own
   * @method isEmpty
   * @static
   * @return {boolean} true if the object is empty.
   * @since 3.2.0
   */
  O.isEmpty = function(o) {
      for (var i in o) {
          if (owns(o, i)) {
              return false;
          }
      }
      return true;
  };
  /**
   * 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.  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 (e.g., Gecko 1.8.0.9
   * reports 1.8).
   * @class UA
   * @static
   */
  /**
  * Static method for parsing the UA string. Defaults to assigning it's value to Y.UA
  * @static
  * @method Env.parseUA
  * @param {String} subUA Parse this UA string instead of navigator.userAgent
  * @returns {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,
  
          /**
           * 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
           * @static
           */
          mobile: null,
  
          /**
           * 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 float
           * @static
           */
          ios: null,
          /**
           * Detects Googles Android OS version
           * @property android
           * @type float
           * @static
           */
          android: 0,
          /**
           * 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
           * @static
           */
          os: null
  
      },
  
      ua = subUA || nav && nav.userAgent,
  
      loc = win && win.location,
  
      href = loc && loc.href,
  
      m;
  
      o.secure = href && (href.toLowerCase().indexOf('https') === 0);
  
      if (ua) {
  
          if ((/windows|win32/i).test(ua)) {
              o.os = 'windows';
          } else if ((/macintosh/i).test(ua)) {
              o.os = 'macintosh';
          } 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;
          }
          // Modern WebKit browsers are at least X-Grade
          m = ua.match(/AppleWebKit\/([^\s]*)/);
          if (m && m[1]) {
              o.webkit = numberify(m[1]);
  
              // Mobile browser check
              if (/ Mobile\//.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.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[^\/]*|Android \d\.\d|webOS\/\d\.\d/);
                  if (m) {
                      // Nokia N-series, Android, 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)) {
                      o.mobile = 'Android';
                      m = ua.match(/Android ([^\s]*);/);
                      if (m && m[1]) {
                          o.android = numberify(m[1]);
                      }
  
                  }
              }
  
              m = ua.match(/Chrome\/([^\s]*)/);
              if (m && m[1]) {
                  o.chrome = numberify(m[1]); // 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)
              m = ua.match(/Opera[\s\/]([^\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]);
                          }
                      }
                  }
              }
          }
      }
  
      YUI.Env.UA = o;
  
      return o;
  };
  
  
  Y.UA = YUI.Env.UA || YUI.Env.parseUA();
  
  
  }, '@VERSION@' );
  YUI.add('get', function(Y) {
  
  
  /**
   * Provides a mechanism to fetch remote resources and
   * insert them into a document.
   * @module yui
   * @submodule get
   */
  
  var ua = Y.UA,
      L = Y.Lang,
      TYPE_JS = 'text/javascript',
      TYPE_CSS = 'text/css',
      STYLESHEET = 'stylesheet';
  
  /**
   * Fetches and inserts one or more script or link nodes into the document
   * @class Get
   * @static
   */
  Y.Get = function() {
  
      /**
       * hash of queues to manage multiple requests
       * @property queues
       * @private
       */
      var _get, _purge, _track,
  
      queues = {},
  
      /**
       * queue index used to generate transaction ids
       * @property qidx
       * @type int
       * @private
       */
      qidx = 0,
  
      /**
       * interal property used to prevent multiple simultaneous purge
       * processes
       * @property purging
       * @type boolean
       * @private
       */
      purging,
  
  
      /**
       * Generates an HTML element, this is not appended to a document
       * @method _node
       * @param {string} type the type of element.
       * @param {string} attr the attributes.
       * @param {Window} win optional window to create the element in.
       * @return {HTMLElement} the generated node.
       * @private
       */
      _node = function(type, attr, win) {
          var w = win || Y.config.win,
              d = w.document,
              n = d.createElement(type),
              i;
  
          for (i in attr) {
              if (attr[i] && attr.hasOwnProperty(i)) {
                  n.setAttribute(i, attr[i]);
              }
          }
  
          return n;
      },
  
      /**
       * Generates a link node
       * @method _linkNode
       * @param {string} url the url for the css file.
       * @param {Window} win optional window to create the node in.
       * @param {object} attributes optional attributes collection to apply to the
       * new node.
       * @return {HTMLElement} the generated node.
       * @private
       */
      _linkNode = function(url, win, attributes) {
          var o = {
              id: Y.guid(),
              type: TYPE_CSS,
              rel: STYLESHEET,
              href: url
          };
          if (attributes) {
              Y.mix(o, attributes);
          }
          return _node('link', o, win);
      },
  
      /**
       * Generates a script node
       * @method _scriptNode
       * @param {string} url the url for the script file.
       * @param {Window} win optional window to create the node in.
       * @param {object} attributes optional attributes collection to apply to the
       * new node.
       * @return {HTMLElement} the generated node.
       * @private
       */
      _scriptNode = function(url, win, attributes) {
          var o = {
              id: Y.guid(),
              type: TYPE_JS
          };
  
          if (attributes) {
              Y.mix(o, attributes);
          }
  
          o.src = url;
  
          return _node('script', o, win);
      },
  
      /**
       * Returns the data payload for callback functions.
       * @method _returnData
       * @param {object} q the queue.
       * @param {string} msg the result message.
       * @param {string} result the status message from the request.
       * @return {object} the state data from the request.
       * @private
       */
      _returnData = function(q, msg, result) {
          return {
                  tId: q.tId,
                  win: q.win,
                  data: q.data,
                  nodes: q.nodes,
                  msg: msg,
                  statusText: result,
                  purge: function() {
                      _purge(this.tId);
                  }
              };
      },
  
      /**
       * The transaction is finished
       * @method _end
       * @param {string} id the id of the request.
       * @param {string} msg the result message.
       * @param {string} result the status message from the request.
       * @private
       */
      _end = function(id, msg, result) {
          var q = queues[id], sc;
          if (q && q.onEnd) {
              sc = q.context || q;
              q.onEnd.call(sc, _returnData(q, msg, result));
          }
      },
  
      /*
       * The request failed, execute fail handler with whatever
       * was accomplished.  There isn't a failure case at the
       * moment unless you count aborted transactions
       * @method _fail
       * @param {string} id the id of the request
       * @private
       */
      _fail = function(id, msg) {
          Y.log('get failure: ' + msg, 'warn', 'get');
  
          var q = queues[id], sc;
          if (q.timer) {
              // q.timer.cancel();
              clearTimeout(q.timer);
          }
  
          // execute failure callback
          if (q.onFailure) {
              sc = q.context || q;
              q.onFailure.call(sc, _returnData(q, msg));
          }
  
          _end(id, msg, 'failure');
      },
  
      /**
       * The request is complete, so executing the requester's callback
       * @method _finish
       * @param {string} id the id of the request.
       * @private
       */
      _finish = function(id) {
          // Y.log("Finishing transaction " + id, "info", "get");
          var q = queues[id], msg, sc;
          if (q.timer) {
              // q.timer.cancel();
              clearTimeout(q.timer);
          }
          q.finished = true;
  
          if (q.aborted) {
              msg = 'transaction ' + id + ' was aborted';
              _fail(id, msg);
              return;
          }
  
          // execute success callback
          if (q.onSuccess) {
              sc = q.context || q;
              q.onSuccess.call(sc, _returnData(q));
          }
  
          _end(id, msg, 'OK');
      },
  
      /**
       * Timeout detected
       * @method _timeout
       * @param {string} id the id of the request.
       * @private
       */
      _timeout = function(id) {
          Y.log('Timeout ' + id, 'info', 'get');
          var q = queues[id], sc;
          if (q.onTimeout) {
              sc = q.context || q;
              q.onTimeout.call(sc, _returnData(q));
          }
  
          _end(id, 'timeout', 'timeout');
      },
  
  
      /**
       * Loads the next item for a given request
       * @method _next
       * @param {string} id the id of the request.
       * @param {string} loaded the url that was just loaded, if any.
       * @return {string} the result.
       * @private
       */
      _next = function(id, loaded) {
  // Y.log("_next: " + id + ", loaded: " + (loaded || "nothing"), "info", "get");
          var q = queues[id], msg, w, d, h, n, url, s,
              insertBefore;
  
          if (q.timer) {
              // Y.log('cancel timer');
              // q.timer.cancel();
              clearTimeout(q.timer);
          }
  
          if (q.aborted) {
              msg = 'transaction ' + id + ' was aborted';
              _fail(id, msg);
              return;
          }
  
          if (loaded) {
              q.url.shift();
              if (q.varName) {
                  q.varName.shift();
              }
          } else {
              // This is the first pass: make sure the url is an array
              q.url = (L.isString(q.url)) ? [q.url] : q.url;
              if (q.varName) {
                  q.varName = (L.isString(q.varName)) ? [q.varName] : q.varName;
              }
          }
  
          w = q.win;
          d = w.document;
          h = d.getElementsByTagName('head')[0];
  
          if (q.url.length === 0) {
              _finish(id);
              return;
          }
  
          url = q.url[0];
  
          // if the url is undefined, this is probably a trailing comma
          // problem in IE.
          if (!url) {
              q.url.shift();
              Y.log('skipping empty url');
              return _next(id);
          }
  
          Y.log('attempting to load ' + url, 'info', 'get');
  
          if (q.timeout) {
              // Y.log('create timer');
              // q.timer = L.later(q.timeout, q, _timeout, id);
              q.timer = setTimeout(function() {
                  _timeout(id);
              }, q.timeout);
          }
  
          if (q.type === 'script') {
              n = _scriptNode(url, w, q.attributes);
          } else {
              n = _linkNode(url, w, q.attributes);
          }
  
          // track this node's load progress
          _track(q.type, n, id, url, w, q.url.length);
  
          // add the node to the queue so we can return it to the user supplied
          // callback
          q.nodes.push(n);
  
          // add it to the head or insert it before 'insertBefore'.  Work around
          // IE bug if there is a base tag.
          insertBefore = q.insertBefore ||
                         d.getElementsByTagName('base')[0];
  
          if (insertBefore) {
              s = _get(insertBefore, id);
              if (s) {
                  Y.log('inserting before: ' + insertBefore, 'info', 'get');
                  s.parentNode.insertBefore(n, s);
              }
          } else {
              h.appendChild(n);
          }
  
          // Y.log("Appending node: " + url, "info", "get");
  
          // FireFox does not support the onload event for link nodes, so
          // there is no way to make the css requests synchronous. This means
          // that the css rules in multiple files could be applied out of order
          // in this browser if a later request returns before an earlier one.
          // Safari too.
          if ((ua.webkit || ua.gecko) && q.type === 'css') {
              _next(id, url);
          }
      },
  
      /**
       * Removes processed queues and corresponding nodes
       * @method _autoPurge
       * @private
       */
      _autoPurge = function() {
          if (purging) {
              return;
          }
          purging = true;
  
          var i, q;
  
          for (i in queues) {
              if (queues.hasOwnProperty(i)) {
                  q = queues[i];
                  if (q.autopurge && q.finished) {
                      _purge(q.tId);
                      delete queues[i];
                  }
              }
          }
  
          purging = false;
      },
  
      /**
       * Saves the state for the request and begins loading
       * the requested urls
       * @method queue
       * @param {string} type the type of node to insert.
       * @param {string} url the url to load.
       * @param {object} opts the hash of options for this request.
       * @return {object} transaction object.
       * @private
       */
      _queue = function(type, url, opts) {
          opts = opts || {};
  
          var id = 'q' + (qidx++), q,
              thresh = opts.purgethreshold || Y.Get.PURGE_THRESH;
  
          if (qidx % thresh === 0) {
              _autoPurge();
          }
  
          queues[id] = Y.merge(opts, {
              tId: id,
              type: type,
              url: url,
              finished: false,
              nodes: []
          });
  
          q = queues[id];
          q.win = q.win || Y.config.win;
          q.context = q.context || q;
          q.autopurge = ('autopurge' in q) ? q.autopurge :
                        (type === 'script') ? true : false;
  
          q.attributes = q.attributes || {};
          q.attributes.charset = opts.charset || q.attributes.charset || 'utf-8';
  
          _next(id);
  
          return {
              tId: id
          };
      };
  
      /**
       * Detects when a node has been loaded.  In the case of
       * script nodes, this does not guarantee that contained
       * script is ready to use.
       * @method _track
       * @param {string} type the type of node to track.
       * @param {HTMLElement} n the node to track.
       * @param {string} id the id of the request.
       * @param {string} url the url that is being loaded.
       * @param {Window} win the targeted window.
       * @param {int} qlength the number of remaining items in the queue,
       * including this one.
       * @param {Function} trackfn function to execute when finished
       * the default is _next.
       * @private
       */
      _track = function(type, n, id, url, win, qlength, trackfn) {
          var f = trackfn || _next;
  
          // IE supports the readystatechange event for script and css nodes
          // Opera only for script nodes.  Opera support onload for script
          // nodes, but this doesn't fire when there is a load failure.
          // The onreadystatechange appears to be a better way to respond
          // to both success and failure.
          if (ua.ie) {
              n.onreadystatechange = function() {
                  var rs = this.readyState;
                  if ('loaded' === rs || 'complete' === rs) {
                      // Y.log(id + " onreadstatechange " + url, "info", "get");
                      n.onreadystatechange = null;
                      f(id, url);
                  }
              };
  
          // webkit prior to 3.x is no longer supported
          } else if (ua.webkit) {
              if (type === 'script') {
                  // Safari 3.x supports the load event for script nodes (DOM2)
                  n.addEventListener('load', function() {
                      // Y.log(id + " DOM2 onload " + url, "info", "get");
                      f(id, url);
                  });
              }
  
          // FireFox and Opera support onload (but not DOM2 in FF) handlers for
          // script nodes.  Opera, but not FF, supports the onload event for link
          // nodes.
          } else {
              n.onload = function() {
                  // Y.log(id + " onload " + url, "info", "get");
                  f(id, url);
              };
  
              n.onerror = function(e) {
                  _fail(id, e + ': ' + url);
              };
          }
      };
  
      _get = function(nId, tId) {
          var q = queues[tId],
              n = (L.isString(nId)) ? q.win.document.getElementById(nId) : nId;
          if (!n) {
              _fail(tId, 'target node not found: ' + nId);
          }
  
          return n;
      };
  
      /**
       * Removes the nodes for the specified queue
       * @method _purge
       * @param {string} tId the transaction id.
       * @private
       */
      _purge = function(tId) {
          var n, l, d, h, s, i, node, attr, insertBefore,
              q = queues[tId];
  
          if (q) {
              n = q.nodes;
              l = n.length;
              d = q.win.document;
              h = d.getElementsByTagName('head')[0];
  
              insertBefore = q.insertBefore ||
                             d.getElementsByTagName('base')[0];
  
              if (insertBefore) {
                  s = _get(insertBefore, tId);
                  if (s) {
                      h = s.parentNode;
                  }
              }
  
              for (i = 0; i < l; i = i + 1) {
                  node = n[i];
                  if (node.clearAttributes) {
                      node.clearAttributes();
                  } else {
                      for (attr in node) {
                          if (node.hasOwnProperty(attr)) {
                              delete node[attr];
                          }
                      }
                  }
  
                  h.removeChild(node);
              }
          }
          q.nodes = [];
      };
  
      return {
  
          /**
           * The number of request required before an automatic purge.
           * Can be configured via the 'purgethreshold' config
           * property PURGE_THRESH
           * @static
           * @type int
           * @default 20
           * @private
           */
          PURGE_THRESH: 20,
  
          /**
           * Called by the the helper for detecting script load in Safari
           * @method _finalize
           * @static
           * @param {string} id the transaction id.
           * @private
           */
          _finalize: function(id) {
              Y.log(id + ' finalized ', 'info', 'get');
              setTimeout(function() {
                  _finish(id);
              }, 0);
          },
  
          /**
           * Abort a transaction
           * @method abort
           * @static
           * @param {string|object} o Either the tId or the object returned from
           * script() or css().
           */
          abort: function(o) {
              var id = (L.isString(o)) ? o : o.tId,
                  q = queues[id];
              if (q) {
                  Y.log('Aborting ' + id, 'info', 'get');
                  q.aborted = true;
              }
          },
  
          /**
           * Fetches and inserts one or more script nodes into the head
           * of the current document or the document in a specified window.
           *
           * @method script
           * @static
           * @param {string|string[]} url the url or urls to the script(s).
           * @param {object} opts Options:
           * <dl>
           * <dt>onSuccess</dt>
           * <dd>
           * callback to execute when the script(s) are finished loading
           * The callback receives an object back with the following
           * data:
           * <dl>
           * <dt>win</dt>
           * <dd>the window the script(s) were inserted into</dd>
           * <dt>data</dt>
           * <dd>the data object passed in when the request was made</dd>
           * <dt>nodes</dt>
           * <dd>An array containing references to the nodes that were
           * inserted</dd>
           * <dt>purge</dt>
           * <dd>A function that, when executed, will remove the nodes
           * that were inserted</dd>
           * <dt>
           * </dl>
           * </dd>
           * <dt>onTimeout</dt>
           * <dd>
           * callback to execute when a timeout occurs.
           * The callback receives an object back with the following
           * data:
           * <dl>
           * <dt>win</dt>
           * <dd>the window the script(s) were inserted into</dd>
           * <dt>data</dt>
           * <dd>the data object passed in when the request was made</dd>
           * <dt>nodes</dt>
           * <dd>An array containing references to the nodes that were
           * inserted</dd>
           * <dt>purge</dt>
           * <dd>A function that, when executed, will remove the nodes
           * that were inserted</dd>
           * <dt>
           * </dl>
           * </dd>
           * <dt>onEnd</dt>
           * <dd>a function that executes when the transaction finishes,
           * regardless of the exit path</dd>
           * <dt>onFailure</dt>
           * <dd>
           * callback to execute when the script load operation fails
           * The callback receives an object back with the following
           * data:
           * <dl>
           * <dt>win</dt>
           * <dd>the window the script(s) were inserted into</dd>
           * <dt>data</dt>
           * <dd>the data object passed in when the request was made</dd>
           * <dt>nodes</dt>
           * <dd>An array containing references to the nodes that were
           * inserted successfully</dd>
           * <dt>purge</dt>
           * <dd>A function that, when executed, will remove any nodes
           * that were inserted</dd>
           * <dt>
           * </dl>
           * </dd>
           * <dt>context</dt>
           * <dd>the execution context for the callbacks</dd>
           * <dt>win</dt>
           * <dd>a window other than the one the utility occupies</dd>
           * <dt>autopurge</dt>
           * <dd>
           * setting to true will let the utilities cleanup routine purge
           * the script once loaded
           * </dd>
           * <dt>purgethreshold</dt>
           * <dd>
           * The number of transaction before autopurge should be initiated
           * </dd>
           * <dt>data</dt>
           * <dd>
           * data that is supplied to the callback when the script(s) are
           * loaded.
           * </dd>
           * <dt>insertBefore</dt>
           * <dd>node or node id that will become the new node's nextSibling.
           * If this is not specified, nodes will be inserted before a base
           * tag should it exist.  Otherwise, the nodes will be appended to the
           * end of the document head.</dd>
           * </dl>
           * <dt>charset</dt>
           * <dd>Node charset, default utf-8 (deprecated, use the attributes
           * config)</dd>
           * <dt>attributes</dt>
           * <dd>An object literal containing additional attributes to add to
           * the link tags</dd>
           * <dt>timeout</dt>
           * <dd>Number of milliseconds to wait before aborting and firing
           * the timeout event</dd>
           * <pre>
           * &nbsp; Y.Get.script(
           * &nbsp; ["http://yui.yahooapis.com/2.5.2/build/yahoo/yahoo-min.js",
           * &nbsp;  "http://yui.yahooapis.com/2.5.2/build/event/event-min.js"],
           * &nbsp; &#123;
           * &nbsp;   onSuccess: function(o) &#123;
           * &nbsp;     this.log("won't cause error because Y is the context");
           * &nbsp;     Y.log(o.data); // foo
           * &nbsp;     Y.log(o.nodes.length === 2) // true
           * &nbsp;     // o.purge(); // optionally remove the script nodes
           * &nbsp;                   // immediately
           * &nbsp;   &#125;,
           * &nbsp;   onFailure: function(o) &#123;
           * &nbsp;     Y.log("transaction failed");
           * &nbsp;   &#125;,
           * &nbsp;   onTimeout: function(o) &#123;
           * &nbsp;     Y.log("transaction timed out");
           * &nbsp;   &#125;,
           * &nbsp;   data: "foo",
           * &nbsp;   timeout: 10000, // 10 second timeout
           * &nbsp;   context: Y, // make the YUI instance
           * &nbsp;   // win: otherframe // target another window/frame
           * &nbsp;   autopurge: true // allow the utility to choose when to
           * &nbsp;                   // remove the nodes
           * &nbsp;   purgetheshold: 1 // purge previous transaction before
           * &nbsp;                    // next transaction
           * &nbsp; &#125;);.
           * </pre>
           * @return {tId: string} an object containing info about the
           * transaction.
           */
          script: function(url, opts) {
              return _queue('script', url, opts);
          },
  
          /**
           * Fetches and inserts one or more css link nodes into the
           * head of the current document or the document in a specified
           * window.
           * @method css
           * @static
           * @param {string} url the url or urls to the css file(s).
           * @param {object} opts Options:
           * <dl>
           * <dt>onSuccess</dt>
           * <dd>
           * callback to execute when the css file(s) are finished loading
           * The callback receives an object back with the following
           * data:
           * <dl>win</dl>
           * <dd>the window the link nodes(s) were inserted into</dd>
           * <dt>data</dt>
           * <dd>the data object passed in when the request was made</dd>
           * <dt>nodes</dt>
           * <dd>An array containing references to the nodes that were
           * inserted</dd>
           * <dt>purge</dt>
           * <dd>A function that, when executed, will remove the nodes
           * that were inserted</dd>
           * <dt>
           * </dl>
           * </dd>
           * <dt>context</dt>
           * <dd>the execution context for the callbacks</dd>
           * <dt>win</dt>
           * <dd>a window other than the one the utility occupies</dd>
           * <dt>data</dt>
           * <dd>
           * data that is supplied to the callbacks when the nodes(s) are
           * loaded.
           * </dd>
           * <dt>insertBefore</dt>
           * <dd>node or node id that will become the new node's nextSibling</dd>
           * <dt>charset</dt>
           * <dd>Node charset, default utf-8 (deprecated, use the attributes
           * config)</dd>
           * <dt>attributes</dt>
           * <dd>An object literal containing additional attributes to add to
           * the link tags</dd>
           * </dl>
           * <pre>
           * Y.Get.css("http://localhost/css/menu.css");
           * </pre>
           * <pre>
           * &nbsp; Y.Get.css(
           * &nbsp; ["http://localhost/css/menu.css",
           * &nbsp;  "http://localhost/css/logger.css"], &#123;
           * &nbsp;   insertBefore: 'custom-styles' // nodes will be inserted
           * &nbsp;                                 // before the specified node
           * &nbsp; &#125;);.
           * </pre>
           * @return {tId: string} an object containing info about the
           * transaction.
           */
          css: function(url, opts) {
              return _queue('css', url, opts);
          }
      };
  }();
  
  
  
  }, '@VERSION@' ,{requires:['yui-base']});
  YUI.add('features', function(Y) {
  
  var feature_tests = {};
  
  Y.mix(Y.namespace('Features'), {
  
      tests: feature_tests,
  
      add: function(cat, name, o) {
          feature_tests[cat] = feature_tests[cat] || {};
          feature_tests[cat][name] = o;
      },
  
      all: function(cat, args) {
          var cat_o = feature_tests[cat],
              // results = {};
              result = '';
          if (cat_o) {
              Y.Object.each(cat_o, function(v, k) {
                  // results[k] = Y.Features.test(cat, k, args);
                  result += k + ':' +
                         (Y.Features.test(cat, k, args) ? 1 : 0) + ';';
              });
          }
  
          return result;
      },
  
      test: function(cat, name, args) {
          args = args || [];
          var result, ua, test,
              cat_o = feature_tests[cat],
              feature = cat_o && cat_o[name];
  
          if (!feature) {
              Y.log('Feature test ' + cat + ', ' + name + ' not found');
          } 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/meta_join.py */
  var add = Y.Features.add;
  // autocomplete-list-keys-sniff.js
  add('load', '0', {
      "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"
  });
  // ie-style-test.js
  add('load', '1', {
      "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"
  });
  // 0
  add('load', '2', {
      "trigger": "widget-base", 
      "ua": "ie"
  });
  // ie-base-test.js
  add('load', '3', {
      "test": function(Y) {
      var imp = Y.config.doc && Y.config.doc.implementation;
      return (imp && (!imp.hasFeature('Events', '2.0')));
  }, 
      "trigger": "node-base"
  });
  // dd-gestures-test.js
  add('load', '4', {
      "test": function(Y) {
      return (Y.config.win && ('ontouchstart' in Y.config.win && !Y.UA.chrome));
  }, 
      "trigger": "dd-drag"
  });
  // history-hash-ie-test.js
  add('load', '5', {
      "test": function (Y) {
      var docMode = Y.config.doc.documentMode;
  
      return Y.UA.ie && (!('onhashchange' in Y.config.win) ||
              !docMode || docMode < 8);
  }, 
      "trigger": "history-hash"
  });
  
  
  }, '@VERSION@' ,{requires:['yui-base']});
  YUI.add('rls', function(Y) {
  
  /**
   * Implentation for building the remote loader service url.
   * @method _rls
   * @param {Array} what the requested modules.
   * @since 3.2.0
   * @return {string} the url for the remote loader service call.
   */
  Y._rls = function(what) {
  
      var config = Y.config,
  
          // the configuration
          rls = config.rls || {
              m: 1, // required in the template
              v: Y.version,
              gv: config.gallery,
              env: 1, // required in the template
              lang: config.lang,
              '2in3v': config['2in3'],
              '2v': config.yui2,
              filt: config.filter,
              filts: config.filters,
              tests: 1 // required in the template
          },
  
          // The rls base path
          rls_base = config.rls_base || 'load?',
  
          // the template
          rls_tmpl = config.rls_tmpl || function() {
              var s = '', param;
              for (param in rls) {
                  if (param in rls && rls[param]) {
                      s += param + '={' + param + '}&';
                  }
              }
              // console.log('rls_tmpl: ' + s);
              return s;
          }(),
  
          url;
  
      // update the request
      rls.m = what;
      rls.env = Y.Object.keys(YUI.Env.mods);
      rls.tests = Y.Features.all('load', [Y]);
  
      url = Y.Lang.sub(rls_base + rls_tmpl, rls);
  
      config.rls = rls;
      config.rls_tmpl = rls_tmpl;
  
      // console.log(url);
      return url;
  };
  
  
  
  }, '@VERSION@' ,{requires:['get','features']});
  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.
   * @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
          if (src) {
              excl = c.logExclude;
              incl = c.logInclude;
              if (incl && !(src in incl)) {
                  bail = 1;
              } else if (excl && (src in excl)) {
                  bail = 1;
              }
          }
          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
   * @module yui
   * @submodule yui-later
   */
  
  /**
   * 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.
   * @method later
   * @for YUI
   * @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].
   * @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;
  
      var m = fn, f, id;
  
      if (o && Y.Lang.isString(fn)) {
          m = o[fn];
      }
  
      f = !Y.Lang.isUndefined(data) ? function() {
          m.apply(o, Y.Array(data));
      } : function() {
          m.call(o);
      };
  
      id = (periodic) ? setInterval(f, when) : setTimeout(f, when);
  
      return {
          id: id,
          interval: periodic,
          cancel: function() {
              if (this.interval) {
                  clearInterval(id);
              } else {
                  clearTimeout(id);
              }
          }
      };
  };
  
  Y.Lang.later = Y.later;
  
  
  
  }, '@VERSION@' ,{requires:['yui-base']});
  YUI.add('yui-throttle', function(Y) {
  
  /**
   * Provides a throttle/limiter for function calls
   * @module yui
   * @submodule yui-throttle
   */
  
  /*! Based on work by Simon Willison: http://gist.github.com/292562 */
  /**
   * Throttles a call to a method based on the time between calls.
   * @method throttle
   * @for YUI
   * @param fn {function} The function call to throttle.
   * @param ms {int} The number of milliseconds to throttle the method call.
   * Can set globally with Y.config.throttleTime or by call. Passing a -1 will
   * disable the throttle. Defaults to 150.
   * @return {function} Returns a wrapped function that calls fn throttled.
   * @since 3.1.0
   */
  Y.throttle = function(fn, ms) {
      ms = (ms) ? ms : (Y.config.throttleTime || 150);
  
      if (ms === -1) {
          return (function() {
              fn.apply(null, arguments);
          });
      }
  
      var last = Y.Lang.now();
  
      return (function() {
          var now = Y.Lang.now();
          if (now - last > ms) {
              last = now;
              fn.apply(null, arguments);
          }
      });
  };
  
  
  }, '@VERSION@' ,{requires:['yui-base']});
  
  
  YUI.add('yui', function(Y){}, '@VERSION@' ,{use:['yui-base','get','features','rls','intl-base','yui-log','yui-later','yui-throttle']});
  
  