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

Mercurial Mercurial > comt / comparison

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

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

changeset 0

40c8f766c9b8

equal deleted inserted replaced

--1:000000000000
+:40c8f766c9b8
+/*
+Copyright (c) 2009, Yahoo! Inc. All rights reserved.
+Code licensed under the BSD License:
+http://developer.yahoo.net/yui/license.txt
+version: 3.0.0b1
+build: 1163
+*/
+(function() {
+var _instances = {},
+_startTime = new Date().getTime(),
+p,
+i,
+add = function () {
+if (window.addEventListener) {
+return function(el, type, fn, capture) {
+el.addEventListener(type, fn, (!!capture));
+};
+} else if (window.attachEvent) {
+return function(el, type, fn) {
+el.attachEvent("on" + type, fn);
+};
+} else {
+return function(){};
+}
+}(),
+remove = function() {
+if (window.removeEventListener) {
+return function (el, type, fn, capture) {
+el.removeEventListener(type, fn, !!capture);
+};
+} else if (window.detachEvent) {
+return function (el, type, fn) {
+el.detachEvent("on" + type, fn);
+};
+} else {
+return function(){};
+}
+}(),
+globalListener = function() {
+YUI.Env.windowLoaded = true;
+YUI.Env.DOMReady = true;
+remove(window, 'load', globalListener);
+},
+// @TODO: this needs to be created at build time from module metadata
+_APPLY_TO_WHITE_LIST = {
+'io.xdrReady': 1,
+'io.start': 1,
+'io.success': 1,
+'io.failure': 1
+},
+SLICE = Array.prototype.slice;
+// reduce to one or the other
+if (typeof YUI === 'undefined' || !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.
+*
+* @class YUI
+* @constructor
+* @global
+* @uses EventTarget
+* @param o Optional configuration object.  This object is stored
+* in YUI.config.  See config for the list of supported properties.
+*/
+/*global YUI*/
+// Make a function, disallow direct instantiation
+YUI = function(o) {
+var Y = this;
+// Allow instantiation without the new operator
+if (!(Y instanceof YUI)) {
+return new YUI(o);
+} else {
+// set up the core environment
+Y._init(o);
+// bind the specified additional modules for this instance
+Y._setup();
+return Y;
+}
+};
+}
+// The prototype contains the functions that are required to allow the external
+// modules to be registered and for the instance to be initialized.
+YUI.prototype = {
+/**
+* Initialize this YUI instance
+* @param o config options
+* @private
+*/
+_init: function(o) {
+o = o || {};
+// find targeted window/frame
+// @TODO create facades
+var v = '3.0.0b1', Y = this;
+o.win = o.win || window || {};
+o.win = o.win.contentWindow || o.win;
+o.doc = o.win.document;
+o.debug = ('debug' in o) ? o.debug : true;
+o.useBrowserConsole = ('useBrowserConsole' in o) ? o.useBrowserConsole : true;
+o.throwFail = ('throwFail' in o) ? o.throwFail : true;
+// add a reference to o for anything that needs it
+// before _setup is called.
+Y.config = o;
+Y.Env = {
+// @todo expand the new module metadata
+mods: {},
+_idx: 0,
+_used: {},
+_attached: {},
+_yidx: 0,
+_uidx: 0,
+_loaded: {}
+};
+if (v.indexOf('@') > -1) {
+v = 'test';
+}
+Y.version = v;
+Y.Env._loaded[v] = {};
+if (YUI.Env) {
+Y.Env._yidx = (++YUI.Env._yidx);
+Y.Env._guidp = ('yui_' + this.version + '-' + Y.Env._yidx + '-' + _startTime).replace(/\./g, '_');
+Y.id = Y.stamp(Y);
+_instances[Y.id] = Y;
+}
+Y.constructor = YUI;
+// this.log(this.id + ') init ');
+},
+/**
+* Finishes the instance setup. Attaches whatever modules were defined
+* when the yui modules was registered.
+* @method _setup
+* @private
+*/
+_setup: function(o) {
+this.use("yui-base");
+// @TODO eval the need to copy the config
+this.config = this.merge(this.config);
+},
+/**
+* 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_WHITE_LIST)) {
+this.error(method + ': applyTo not allowed');
+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.error('applyTo not found: ' + method);
+}
+}
+return m.apply(instance, args);
+}
+return null;
+},
+/**
+* Register a 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 optional config data:
+* requires   - features that should be present before loading
+* optional   - optional features that should be present if load optional defined
+* use  - features that should be attached automatically
+* skinnable  -
+* rollup
+* omit - features that should not be loaded if this module is present
+* @return {YUI} the YUI instance
+*
+*/
+add: function(name, fn, version, details) {
+// this.log('Adding a new component ' + name);
+// @todo expand this to include version mapping
+// @todo allow requires/supersedes
+// @todo may want to restore the build property
+// @todo fire moduleAvailable event
+var m = {
+name: name,
+fn: fn,
+version: version,
+details: details || {}
+};
+YUI.Env.mods[name] = m;
+return this; // chain support
+},
+_attach: function(r, fromLoader) {
+var mods = YUI.Env.mods,
+attached = this.Env._attached,
+i, l = r.length, name, m, d, req, use;
+for (i=0; i<l; i=i+1) {
+name = r[i];
+m    = mods[name];
+if (!attached[name] && m) {
+attached[name] = true;
+d   = m.details;
+req = d.requires;
+use = d.use;
+if (req) {
+this._attach(this.Array(req));
+}
+// this.log('attaching ' + name, 'info', 'yui');
+if (m.fn) {
+m.fn(this);
+}
+if (use) {
+this._attach(this.Array(use));
+}
+}
+}
+},
+/**
+* Bind a module to a YUI instance
+* @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.
+*
+* @TODO
+* Implement versioning?  loader can load different versions?
+* Should sub-modules/plugins be normal modules, or do
+* we add syntax for specifying these?
+*
+* YUI().use('dragdrop')
+* YUI().use('dragdrop:2.4.0'); // specific version
+* YUI().use('dragdrop:2.4.0-'); // at least this version
+* YUI().use('dragdrop:2.4.0-2.9999.9999'); // version range
+* YUI().use('*'); // use all available modules
+* YUI().use('lang+dump+substitute'); // use lang and some plugins
+* YUI().use('lang+*'); // use lang and all known plugins
+*
+*
+* @return {YUI} the YUI instance
+*/
+use: function() {
+if (this._loading) {
+this._useQueue.add(SLICE.call(arguments, 0));
+return this;
+}
+var Y = this,
+a=SLICE.call(arguments, 0),
+mods = YUI.Env.mods,
+used = Y.Env._used,
+loader,
+firstArg = a[0],
+dynamic = false,
+callback = a[a.length-1],
+k, i, l, missing = [],
+r = [],
+f = function(name) {
+// only attach a module once
+if (used[name]) {
+// Y.log(name + ' already used', 'info', 'yui');
+return;
+}
+var m = mods[name], j, req, use;
+if (m) {
+// Y.log('USING ' + name, 'info', 'yui');
+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 (!YUI.Env._loaded[Y.version][name]) {
+Y.log('module not found: ' + name, 'info', 'yui');
+missing.push(name);
+} else {
+// probably css
+// Y.log('module not found BUT HAS BEEN LOADED: ' + name, 'info', 'yui');
+used[name] = true;
+}
+}
+// make sure requirements are attached
+if (req) {
+if (Y.Lang.isString(req)) {
+f(req);
+} else {
+for (j = 0; j < req.length; j = j + 1) {
+// Y.log('using module\'s requirements: ' + name, 'info', 'yui');
+f(req[j]);
+}
+}
+}
+// add this module to full list of things to attach
+// Y.log('adding to requires list: ' + name);
+r.push(name);
+},
+onComplete = function(fromLoader) {
+// Y.log('Use complete');
+fromLoader = fromLoader || {
+success: true,
+msg: 'not dynamic'
+};
+if (Y.Env._callback) {
+var cb = Y.Env._callback;
+Y.Env._callback = null;
+cb(Y, fromLoader);
+}
+if (Y.fire) {
+Y.fire('yui:load', Y, fromLoader);
+}
+// process queued use requests as long until done
+// or dynamic load happens again.
+this._loading = false;
+while (this._useQueue && this._useQueue.size() && !this._loading) {
+Y.use.apply(Y, this._useQueue.next());
+}
+};
+// Y.log(Y.id + ': use called: ' + a + ' :: ' + callback);
+// The last argument supplied to use can be a load complete callback
+if (typeof callback === 'function') {
+a.pop();
+Y.Env._callback = callback;
+} else {
+callback = null;
+}
+// YUI().use('*'); // bind everything available
+if (firstArg === "*") {
+a = [];
+for (k in mods) {
+if (mods.hasOwnProperty(k)) {
+a.push(k);
+}
+}
+// Y.log('Use *: ' + a);
+return Y.use.apply(Y, a);
+}
+// Y.log('loader before: ' + a.join(','));
+// use loader to expand dependencies and sort the
+// requirements if it is available.
+if (Y.Loader) {
+dynamic = true;
+this._useQueue = this._useQueue || new Y.Queue();
+loader = new Y.Loader(Y.config);
+loader.require(a);
+loader.ignoreRegistered = true;
+loader.allowRollup = false;
+loader.calculate();
+a = loader.sorted;
+}
+// Y.log('loader after: ' + a.join(','));
+l = a.length;
+// process each requirement and any additional requirements
+// the module metadata specifies
+for (i=0; i<l; i=i+1) {
+f(a[i]);
+}
+// Y.log('all reqs: ' + r + ' --- missing: ' + missing + ', l: ' + l + ', ' + r[0]);
+// dynamic load
+if (Y.Loader && missing.length) {
+Y.log('Attempting to dynamically load the missing modules ' + missing, 'info', 'yui');
+this._loading = true;
+loader = new Y.Loader(Y.config);
+loader.onSuccess = onComplete;
+loader.onFailure = onComplete;
+loader.onTimeout = onComplete;
+loader.attaching = a;
+loader.require(missing);
+loader.insert();
+} else {
+Y._attach(r);
+onComplete();
+}
+return Y; // chain support var yui = YUI().use('dragdrop');
+},
+/**
+* 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=null, i, j, d;
+for (i=0; i<a.length; i=i+1) {
+d = ("" + a[i]).split(".");
+o = this;
+for (j=(d[0] == "YAHOO") ? 1 : 0; j<d.length; j=j+1) {
+o[d[j]] = o[d[j]] || {};
+o = o[d[j]];
+}
+}
+return o;
+},
+// this is replaced if the log module is included
+log: function() {
+},
+/**
+* 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) {
+if (this.config.throwFail) {
+throw (e || new Error(msg));
+} else {
+this.message(msg, "error"); // don't scrub this one
+}
+return this;
+},
+/**
+* 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) {
+if (!o) {
+return o;
+}
+var uid = (typeof o === 'string') ? o : o._yuid;
+if (!uid) {
+uid = this.guid();
+if (!readOnly) {
+try {
+o._yuid = uid;
+} catch(e) {
+uid = null;
+}
+}
+}
+return uid;
+}
+};
+// Give the YUI global the same properties as an instance.
+// This makes it so that the YUI global can be used like the YAHOO
+// global was used prior to 3.x.  More importantly, the YUI global
+// provides global metadata, so env needs to be configured.
+// @TODO review
+p = YUI.prototype;
+// inheritance utilities are not available yet
+for (i in p) {
+if (true) {
+YUI[i] = p[i];
+}
+}
+// set up the environment
+YUI._init();
+// 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', globalListener);
+YUI.Env.add = add;
+YUI.Env.remove = remove;
+/*
+* Subscribe to an event.  The signature differs depending on the
+* type of event you are attaching to.
+* @method on
+* @param type {string|function|object} The type of the event.  If
+* this is a function, this is dispatched to the aop system.  If an
+* object, it is parsed for multiple subsription definitions
+* @param fn {Function} The callback
+* @param elspec {any} DOM element(s), selector string(s), and or
+* Node ref(s) to attach DOM related events to (only applies to
+* DOM events).
+* @param
+* @return the event target or a detach handle per 'chain' config
+*/
+})();
+/**
+* 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.
+* @class config
+* @static
+*/
+/**
+* Turn debug statements on or off
+* @property debug
+* @type boolean
+* @default true
+*/
+/**
+* Log to the browser console if debug is on and the browser has a
+* supported console
+* @property useBrowserConsole
+* @type boolean
+* @default true
+*/
+/**
+* A hash of log sources that should be logged.  If specified, only log messages from these sources will be logged.
+* @property logInclude
+* @type object
+*/
+/**
+* A hash of log sources that should be not be logged.  If specified, all sources are logged if not on this list.</li>
+* @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 onDOMReady.
+* @property injected
+* @type object
+*/
+/**
+* If throwFail is set, Y.fail 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)</li>
+* @property core
+* @type string[]
+*/
+/**
+* The default date format
+* @property dateFormat
+* @type string
+*/
+/**
+* The default locale
+* @property locale
+* @type string
+*/
+/**
+* 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 names 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
+*/
+/**
+* Hash of per-component filter specification.  If specified for a given component,
+* this overrides the filter config
+* For dynamic loading.
+* @property filters
+* @type object
+*/
+/**
+* Use the YUI combo service to reduce the number of http connections
+* required to load your dependencies
+* 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
+*/
+/**
+* charset for dynamic nodes
+* @property charset
+* @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 list 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.See Loader.addModule for the supported
+* module metadata.
+* @property modules
+* @type function
+*/
+YUI.add('yui-base', function(Y) {
+/*
+* YUI stub
+* @module yui
+* @submodule yui-base
+*/
+(function() {
+var instance = Y,
+LOGEVENT = 'yui:log',
+_published;
+/**
+* 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 Y = instance, c = Y.config, bail = false, exc, inc, m, f;
+// 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) {
+exc = c.logExclude;
+inc = c.logInclude;
+if (inc && !(src in inc)) {
+bail = true;
+} else if (exc && (src in exc)) {
+bail = true;
+}
+}
+if (!bail) {
+if (c.useBrowserConsole) {
+m = (src) ? src + ': ' + msg : msg;
+if (typeof console != 'undefined') {
+f = (cat && console[cat]) ? cat : 'log';
+console[f](m);
+} else if (typeof opera != 'undefined') {
+opera.postError(m);
+}
+}
+if (Y.fire && !bail && !silent) {
+if (!_published) {
+Y.publish(LOGEVENT, {
+broadcast: 2,
+emitFacade: true
+});
+_published = true;
+}
+Y.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);
+};
+/*
+* @TODO I'm not convinced the current log statement scrubbing routine can
+* be made safe with all the variations that could be supplied for
+* the condition.
+*
+* Logs a message with Y.log() if the first parameter is true
+* Y.logIf((life == 'good'), 'yay');
+* logIf statements are stripped from the raw and min files.
+* @method logIf
+* @for YUI
+* @param  {boolean} condition Logging only occurs if a truthy value is provided
+* @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.logIf = function(condition, msg, cat, src, silent) {
+//     if (condition) {
+//         return Y.log.apply(Y, arguments);
+//     }
+// };
+})();
+(function() {
+/**
+* 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',
+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 = '';
+/**
+* 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.  You can use @see Array.test if you
+* want to
+* @method isArray
+* @static
+* @param o The object to test
+* @return {boolean} true if o is an array
+*/
+L.isArray = function(o) {
+return L.type(o) === ARRAY;
+};
+/**
+* Determines whether or not the provided item is a boolean
+* @method isBoolean
+* @static
+* @param o The object to test
+* @return {boolean} true if o is a boolean
+*/
+L.isBoolean = function(o) {
+return typeof o === BOOLEAN;
+};
+/**
+* Determines whether or not the provided item is a function
+* Note: Internet Explorer thinks certain functions are objects:
+*
+* var obj = document.createElement("object");
+* Y.Lang.isFunction(obj.getAttribute) // reports false in IE
+*
+* var input = document.createElement("input"); // append to body
+* Y.Lang.isFunction(input.focus) // reports false in IE
+*
+* You will have to implement additional tests if these functions
+* matter to you.
+*
+* @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;
+};
+/**
+* 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
+* @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) {
+return (o && (typeof o === OBJECT || (!failfn && 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 = function(s){
+try {
+return s.replace(TRIMREGEX, EMPTYSTRING);
+} catch(e) {
+return 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);
+}
+};
+/**
+* Returns a string representing the type of the item passed in.
+* @method type
+* @param o the item to test
+* @return {string} the detected type
+*/
+L.type = function (o) {
+return  TYPES[typeof o] || TYPES[TOSTRING.call(o)] || (o ? OBJECT : NULL);
+};
+})();
+/*
+* Provides information about the environment hosting YUI
+* @module yui
+* @submodule Array
+*/
+(function() {
+var L = Y.Lang, Native = Array.prototype,
+/**
+* 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 o the item to arrayify
+*   @param i {int} if an array or array-like, this is the start index
+*   @param al {boolean} 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, al) {
+var t = (al) ? 2 : Y.Array.test(o), i, l, a;
+// switch (t) {
+//     case 1:
+//         // return (startIdx) ? o.slice(startIdx) : o;
+//     case 2:
+//         return Native.slice.call(o, startIdx || 0);
+//     default:
+//         return [o];
+// }
+if (t) {
+try {
+return Native.slice.call(o, startIdx || 0);
+// IE errors when trying to slice element collections
+} catch(e) {
+a=[];
+for (i=0, l=o.length; i<l; i=i+1) {
+a.push(o[i]);
+}
+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).
+*
+* @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 (L.isObject(o)) {
+if (L.isArray(o)) {
+r = 1;
+} else {
+try {
+// indexed, but no tagName (element) or alert (window)
+if ("length" in o && !("tagName" in o) && !("alert" in o) &&
+(!Y.Lang.isFunction(o.size) || o.size() > 1)) {
+r = 2;
+}
+} catch(e) {}
+}
+}
+return r;
+};
+/**
+* Executes the supplied function on each item in the array.
+* @method each
+* @param a {Array} the array to iterate
+* @param f {Function} the function to execute on each item
+* @param 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 k {Array} keyset
+* @param v {Array} 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 a {Array} the array to search
+* @param 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 a.indexOf(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
+*/
+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 a {Array} the array to iterate
+* @param f {Function} the function to execute on each item
+* @param 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;
+};
+})();
+(function() {
+var L = Y.Lang,
+DELIMITER = '__',
+// FROZEN = {
+//     'prototype': 1,
+//     '_yuid': 1
+// },
+/*
+* 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 (L.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} merge objects instead of overwriting/ignoring
+* 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);
+case 2: // object to object and proto to proto
+Y.mix(r.prototype, s.prototype);
+break; // pass through
+case 3: // proto to static
+return Y.mix(r, s.prototype);
+case 4: // static to proto
+return Y.mix(r.prototype, s);
+default:  // object to object is what happens below
+}
+}
+// Maybe don't even need this wl && wl.length check anymore??
+var arr = merge && L.isArray(r), i, l, p;
+if (wl && wl.length) {
+for (i = 0, l = wl.length; i < l; ++i) {
+p = wl[i];
+if (p in s) {
+if (merge && L.isObject(r[p], true)) {
+Y.mix(r[p], s[p]);
+} else if (!arr && (ov || !(p in r))) {
+r[p] = s[p];
+} else if (arr) {
+r.push(s[p]);
+}
+}
+}
+} else {
+for (i in s) {
+// if (s.hasOwnProperty(i) && !(i in FROZEN)) {
+// 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 && L.isObject(r[i], true)) {
+Y.mix(r[i], s[i]); // recursive
+// otherwise apply the property only if overwrite
+// is specified or the receiver doesn't have one.
+} else if (!arr && (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.
+* @function cached
+* @param source {function} the function to memoize
+* @param cache an optional cache seed
+* @return {Function} the wrapped function
+*/
+Y.cached = function(source, cache){
+cache = cache || {};
+// I want the profiler to show me separate entries for each
+// cached function.  Is this too much to ask?
+// return function cached_sourceFunction
+// return this['cached_' + source.name] = function
+// var a = function(){}; a.name = 'foo'; return a;
+return function cached(arg1, arg2) {
+// (?)()   51  5.76%   0.571ms 1.01ms  0.02ms  0.001ms 0.041ms
+// A() 76  6.58%   0.652ms 0.652ms 0.009ms 0.005ms 0.03ms
+// var key = (arg2 !== undefined) ? Y.Array(arguments, 0, true).join(DELIMITER) : arg1;
+// (?)()   51  8.57%   0.837ms 0.838ms 0.016ms 0.013ms 0.024ms
+// var key = (arguments.length > 1) ? Array.prototype.join.call(arguments, DELIMITER) : arg1;
+// (?)()   51  8.06%  0.761ms 0.762ms 0.015ms 0.002ms 0.025ms
+// var key = (arg2 !== undefined) ? Array.prototype.join.call(arguments, DELIMITER) : arg1;
+// (?)()   51  7.87%   0.749ms 0.751ms 0.015ms 0.001ms 0.027ms
+// A() 30  2.23%   0.214ms 0.214ms 0.007ms 0.005ms 0.009ms
+var key = (arg2) ? Array.prototype.join.call(arguments, DELIMITER) : arg1;
+if (!(key in cache)) {
+cache[key] = source.apply(source, arguments);
+}
+return cache[key];
+};
+};
+})();
+(function() {
+/**
+* Adds the following Object utilities to the YUI instance
+* @class Object
+*/
+/**
+* Y.Object(o) returns a new object based upon the supplied object.
+* @TODO Use native Object.create() when available
+* @method ()
+* @static
+* @param o the supplier object
+* @return {Object} the new object
+*/
+Y.Object = function(o) {
+var F = function() {};
+F.prototype = o;
+return new F();
+};
+var O = Y.Object,
+UNDEFINED = undefined,
+/**
+* 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 (count) {
+out++;
+} else {
+if (o.hasOwnProperty(i)) {
+out.push((what) ? o[i] : i);
+}
+}
+}
+return out;
+};
+/**
+* Returns an array containing the object's keys
+* @TODO use native Object.keys() if available
+* @method keys
+* @static
+* @param o an object
+* @return {string[]} the keys
+*/
+O.keys = function(o) {
+return _extract(o);
+};
+/**
+* Returns an array containing the object's values
+* @TODO use native Object.values() if available
+* @method values
+* @static
+* @param o an object
+* @return {Array} the values
+*/
+O.values = function(o) {
+return _extract(o, 1);
+};
+/**
+* Returns the size of an object
+* @TODO use native Object.size() if available
+* @method size
+* @static
+* @param o an object
+* @return {int} the size
+*/
+O.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 = function(o, k) {
+// return (o.hasOwnProperty(k));
+return (k in o);
+};
+/**
+* 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.
+*
+* @deprecated Safari 1.x support has been removed, so this is simply a
+* wrapper for the native implementation.  Use the native implementation
+* directly instead.
+*
+* @TODO Remove in B1
+*
+* @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 = function(o, k) {
+return (o.hasOwnProperty(k));
+};
+/**
+* Executes a function on each item. The function
+* receives the value, the key, and the object
+* as paramters (in that order).
+* @method each
+* @static
+* @param o the object to iterate
+* @param f {function} the function to execute
+* @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 || o.hasOwnProperty(i)) {
+f.call(s, o[i], i, o);
+}
+}
+return Y;
+};
+/**
+* Retrieves the sub value at the provided path,
+* from the value object provided.
+*
+* @method getValue
+* @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.
+* Returns the source object if an empty path is provided.
+*/
+O.getValue = function (o, path) {
+var p=Y.Array(path), l=p.length, i;
+for (i=0; o !== UNDEFINED && i < l; i=i+1) {
+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
+* @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 p=Y.Array(path), leafIdx=p.length-1, i, ref=o;
+if (leafIdx >= 0) {
+for (i=0; ref !== UNDEFINED && i < leafIdx; i=i+1) {
+ref = ref[p[i]];
+}
+if (ref !== UNDEFINED) {
+ref[p[i]] = val;
+} else {
+return UNDEFINED;
+}
+}
+return o;
+};
+})();
+/*
+* Provides information about the environment hosting YUI
+* @module yui
+* @submodule UA
+*/
+/**
+* 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
+*/
+Y.UA = function() {
+var nav = 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 <-- Reports 1.8
+* Firefox 2.0.0.3: 1.8.1.3 <-- Reports 1.8
+* Firefox 3 alpha: 1.9a4   <-- Reports 1.9
+* </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_(web_browser)#Version_history
+* @property webkit
+* @type float
+* @static
+*/
+webkit: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,
+/**
+* Google Caja version number or 0.
+* @property caja
+* @type float
+*/
+caja: 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 = nav && nav.userAgent,
+loc = Y.config.win.location,
+href = loc && loc.href,
+m;
+o.secure = href && (href.toLowerCase().indexOf("https") === 0);
+if (ua) {
+if ((/windows|win32/).test(ua)) {
+o.os = 'windows';
+} else if ((/macintosh/).test(ua)) {
+o.os = 'macintosh';
+}
+// 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=parseFloat(m[1]);
+// Mobile browser check
+if (/ Mobile\//.test(ua)) {
+o.mobile = "Apple"; // iPhone or iPod Touch
+} else {
+m=ua.match(/NokiaN[^\/]*/);
+if (m) {
+o.mobile = m[0]; // Nokia N-series, ex: NokiaN95
+}
+}
+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=parseFloat(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=parseFloat(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=parseFloat(m[1]);
+}
+}
+}
+}
+}
+}
+return o;
+}();
+(function() {
+var L = Y.Lang,
+/**
+* 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.
+*/
+later = function(when, o, fn, data, periodic) {
+when = when || 0;
+o = o || {};
+var m=fn, d=data, f, r;
+if (L.isString(fn)) {
+m = o[fn];
+}
+if (!m) {
+Y.error("method undefined");
+}
+if (!L.isArray(d)) {
+d = [data];
+}
+f = function() {
+m.apply(o, d);
+};
+r = (periodic) ? setInterval(f, when) : setTimeout(f, when);
+return {
+id: r,
+interval: periodic,
+cancel: function() {
+if (this.interval) {
+clearInterval(r);
+} else {
+clearTimeout(r);
+}
+}
+};
+};
+Y.later = later;
+L.later = later;
+})();
+(function() {
+// var min = ['yui-base', 'log', 'lang', 'array', 'core'], core, C = Y.config;
+var min = ['yui-base'], core, C = Y.config;
+// apply the minimal required functionality
+Y.use.apply(Y, min);
+Y.log(Y.id + ' initialized', 'info', 'yui');
+if (C.core) {
+core = C.core;
+} else {
+core = ['queue-base', 'get', 'loader'];
+}
+Y.use.apply(Y, core);
+})();
+}, '3.0.0b1' );

comt