(function() {

var _instances = {},

_APPLY_TO_WHITE_LIST = {

'io.xdrReady': 1,

'io.start': 1,

'io.success': 1,

'io.failure': 1,

'io.abort': 1

};

if (typeof YUI === 'undefined' || !YUI) {

/**

/*global YUI*/

YUI = function(o) {

var Y = this;

// Allow var yui = YUI() instead of var yui = new YUI()

if (Y == window) {

return new YUI(o);

} else {

// set up the core environment

Y._init(o);

// bind the specified additional modules for this instance

Y._setup();

}

};

}

YUI.prototype = {

/**

_init: function(o) {

o = o || {};

// find targeted window and @TODO create facades

var w = (o.win) ? (o.win.contentWindow) : o.win || window;

o.win = w;

o.doc = w.document;

o.debug = ('debug' in o) ? o.debug : true;

o.useConsole = ('useConsole' in o) ? o.debug : true;

// add a reference to o for anything that needs it

// before _setup is called.

this.config = o;

this.Env = {

// @todo expand the new module metadata

mods: {},

_idx: 0,

_pre: 'yuid',

_used: {},

_attached: {},

_yidx: 0,

_uidx: 0

};

if (YUI.Env) {

this.Env._yidx = ++YUI.Env._idx;

this.id = this.stamp(this);

_instances[this.id] = this;

}

this.constructor = YUI;

this.log(this.id + ') init ');

},

/**

_setup: function(o) {

this.use("yui");

// @TODO eval the need to copy the config

this.config = this.merge(this.config);

},

/**

applyTo: function(id, method, args) {

if (!(method in _APPLY_TO_WHITE_LIST)) {

this.fail(method + ': applyTo not allowed');

return null;

}

var instance = _instances[id];

if (instance) {

var nest = method.split('.'), m = instance;

for (var i=0; i<nest.length; i=i+1) {

m = m[nest[i]];

if (!m) {

this.fail('applyTo not found: ' + method);

}

}

return m.apply(instance, args);

}

return null;

},

/**

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;

for (var i=0, l=r.length; i<l; i=i+1) {

var name = r[i], m = mods[name], mm;

if (!attached[name] && m) {

attached[name] = true;

var d = m.details, req = d.requires, use = d.use;

if (req) {

this._attach(this.Array(req));

}

this.log('attaching ' + name, 'info', 'YUI');

m.fn(this);

if (use) {

this._attach(this.Array(use));

}

}

}

},

/**

use: function() {

var Y = this,

a=Array.prototype.slice.call(arguments, 0),

mods = YUI.Env.mods,

used = Y.Env._used,

loader,

firstArg = a[0],

dynamic = false,

callback = a[a.length-1];

// 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 (var k in mods) {

if (mods.hasOwnProperty(k)) {

a.push(k);

}

}

// if (callback) {

// a.push(callback);

// }

return Y.use.apply(Y, a);

}

// Y.log('loader before: ' + a.join(','));

// use loader to optimize and sort the requirements if it

// is available.

if (Y.Loader) {

dynamic = true;

loader = new Y.Loader(Y.config);

loader.require(a);

loader.ignoreRegistered = true;

loader.calculate();

a = loader.sorted;

}

// Y.log('loader after: ' + a.join(','));

var missing = [], r = [], f = function(name) {

// only attach a module once

if (used[name]) {

// Y.log(name + ' already used');

return;

}

var m = mods[name], j, req, use;

if (m) {

used[name] = true;

if (dynamic) {

// Y.mix(l, YUI.Env.mods);

Y.log('attaching ' + name, 'info', 'YUI');

m.fn(Y);

}

// Y.log('found ' + name);

req = m.details.requires;

use = m.details.use;

} else {

Y.log('module not found: ' + name, 'info', 'YUI');

missing.push(name);

}

// make sure requirements are attached

if (req) {

if (Y.Lang.isString(req)) {

f(req);

} else {

for (j = 0; j < req.length; j = j + 1) {

f(req[j]);

}

}

}

// add this module to full list of things to attach

// Y.log('using ' + name);

r.push(name);

// auto-attach sub-modules

/*

};

// process each requirement and any additional requirements

// the module metadata specifies

for (var i=0, l=a.length; i<l; i=i+1) {

f(a[i]);

}

Y.log('all reqs: ' + r + ' --- missing: ' + missing);

var onComplete = function(fromLoader) {

Y.log('Use complete');

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

}

};

if (Y.Loader && missing.length) {

// dynamic load

Y.log('trying to get the missing modules ' + missing);

loader = new Y.Loader(Y.config);

// loader.subscribe('success', onComplete, Y);

// loader.subscribe('failure', onComplete, Y);

// loader.subscribe('timeout', onComplete, Y);

loader.onSuccess = onComplete;

loader.onFailure = onComplete;

loader.onTimeout = onComplete;

loader.require(missing);

// loader calls use to automatically attach when finished

// but we still need to execute the callback.

loader.insert();

} else {

Y._attach(r);

onComplete();

}

return Y; // chain support var yui = YUI().use('dragdrop');

},

/**

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] == "YUI") ? 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() {

},

/**

fail: function(msg, e) {

var instance = this;

instance.log(msg, "error"); // don't scrub this one

if (this.config.throwFail) {

throw e || new Error(msg);

}

return this;

},

/**

guid: function(pre) {

var e = this.Env, p = (pre) || e._pre;

return p +'-' + e._yidx + '-' + e._uidx++;

},

/**

stamp: function(o) {

if (!o) {

return o;

}

var uid = (typeof o === 'string') ? o : o._yuid;

if (!uid) {

uid = this.guid();

o._yuid = uid;

}

return uid;

}

};

var Y = YUI, p = Y.prototype, i;

// inheritance utilities are not available yet

for (i in p) {

if (true) { // hasOwnProperty not available yet and not needed

Y[i] = p[i];

}

}

// set up the environment

Y._init();

})();

YUI.add("log", function(instance) {

/**

instance.log = function(msg, cat, src) {

var Y = instance, c = Y.config, es = Y.Env._eventstack,

bail = (es && es.logging);

// 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 && !bail) {

if (c.useConsole && typeof console != 'undefined') {

// apply source filters

if (src) {

var exc = c.logExclude, inc = c.logInclude;

// console.log('checking src filter: ' + src + ', inc: ' + inc + ', exc: ' + exc);

if (inc && !(src in inc)) {

// console.log('bail: inc list found, but src is not in list: ' + src);

bail = true;

} else if (exc && (src in exc)) {

// console.log('bail: exc list found, and src is in it: ' + src);

bail = true;

}

}

if (!bail) {

var f = (cat && console[cat]) ? cat : 'log',

m = (src) ? src + ': ' + msg : msg;

console[f](m);

}

}

// category filters are not used to suppress the log event

// so that the data can be stored and displayed later.

if (Y.fire) {

Y.fire('yui:log', msg, cat, src);

}

}

return Y;

};

}, "@VERSION@");

YUI.add("lang", function(Y) {

/**

Y.Lang = Y.Lang || {};

var L = Y.Lang, SPLICE="splice", LENGTH="length";

/**

L.isArray = function(o) {

if (o) {

//return L.isNumber(o.length) && L.isFunction(o.splice);

return (o[SPLICE] && L.isNumber(o[LENGTH]));

}

return false;

};

/**

L.isBoolean = function(o) {

return typeof o === 'boolean';

};

/**

L.isFunction = function(o) {

return typeof o === 'function';

};

/**

L.isDate = function(o) {

return o instanceof Date;

};

/**

L.isNull = function(o) {

return o === null;

};

/**

L.isNumber = function(o) {

return typeof o === 'number' && isFinite(o);

};

/**

L.isObject = function(o, failfn) {

return (o && (typeof o === 'object' || (!failfn && L.isFunction(o)))) || false;

};

/**

L.isString = function(o) {

return typeof o === 'string';

};

/**

L.isUndefined = function(o) {

return typeof o === 'undefined';

};

/**

L.trim = function(s){

try {

return s.replace(/^\s+|\s+$/g, "");

} catch(e) {

return s;

}

};

/**

L.isValue = function(o) {

return (L.isObject(o) || L.isString(o) || L.isNumber(o) || L.isBoolean(o));

};

}, "@VERSION@");

YUI.add("array", function(Y) {

var L = Y.Lang, Native = Array.prototype;

/**

Y.Array = function(o, i, al) {

var t = (al) ? 2 : Y.Array.test(o);

switch (t) {

case 1:

return (i) ? o.slice(o, i) : o;

case 2:

return Native.slice.call(o, i || 0);

default:

return [o];

}

};

var A = Y.Array;

// YUI array utilities. The current plan is to make a few useful

// ones 'core', and to have the rest of the array extras an optional

// module

/**

A.test = function(o) {

var r = 0;

if (L.isObject(o, true)) {

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)) {

r = 2;

}

} catch(ex) {}

}

}

return r;

};

/**

A.each = (Native.forEach) ?

function (a, f, o) {

Native.forEach.call(a, f, o || Y);

return Y;

} :

function (a, f, o) {

var l = a.length, i;

for (i = 0; i < l; i=i+1) {

f.call(o || Y, a[i], i, a);

}

return Y;

};

/**

A.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;

};

/**

A.indexOf = function(a, val) {

for (var i=0; i<a.length; i=i+1) {

if (a[i] === val) {

return i;

}

}

return -1;

};

}, "@VERSION@");

YUI.add("core", function(Y) {

var L = Y.Lang,

A = Y.Array,

OP = Object.prototype,

IEF = ["toString", "valueOf"],

PROTO = 'prototype',

/**

_iefix = (Y.UA && Y.UA.ie) ?

function(r, s, w) {

for (var i=0, a=IEF; i<a.length; i=i+1) {

var n = a[i], f = s[n];

if (L.isFunction(f) && f != OP[n]) {

if (!w || (n in w)) {

r[n]=f;

}

}

}

} : function() {};

/**

Y.merge = function() {

// var o={}, a=arguments;

// for (var i=0, l=a.length; i<l; i=i+1) {

//var a=arguments, o=Y.Object(a[0]);

var a=arguments, o={};

for (var i=0, l=a.length; i<l; i=i+1) {

Y.mix(o, a[i], true);

}

return o;

};

/**

Y.mix = function(r, s, ov, wl, mode, merge) {

if (!s||!r) {

return Y;

}

var w = (wl && wl.length) ? A.hash(wl) : null, m = merge,

f = function(fr, fs, proto, iwl) {

var arr = m && L.isArray(fr);

for (var i in fs) {

// We never want to overwrite the prototype

// if (PROTO === i) {

if (PROTO === i || '_yuid' === i) {

continue;

}

// Y.log('i: ' + i + ", " + fs[i]);

// @TODO deal with the hasownprop issue

// check white list if it was supplied

if (!w || iwl || (i in w)) {

// if the receiver has this property, it is an object,

// and merge is specified, merge the two objects.

if (m && L.isObject(fr[i], true)) {

// console.log('aggregate RECURSE: ' + i);

// @TODO recursive or no?

// Y.mix(fr[i], fs[i]); // not recursive

f(fr[i], fs[i], proto, true); // recursive

// otherwise apply the property only if overwrite

// is specified or the receiver doesn't have one.

// @TODO make sure the 'arr' check isn't desructive

} else if (!arr && (ov || !(i in fr))) {

// console.log('hash: ' + i);

fr[i] = fs[i];

// if merge is specified and the receiver is an array,

// append the array item

} else if (arr) {

// console.log('array: ' + i);

// @TODO probably will need to remove dups

fr.push(fs[i]);

}

}

}

_iefix(fr, fs, w);

};

var rp = r.prototype, sp = s.prototype;

switch (mode) {

case 1: // proto to proto

f(rp, sp, true);

break;

case 2: // object to object and proto to proto

f(r, s);

f(rp, sp, true);

break;

case 3: // proto to static

f(r, sp, true);

break;

case 4: // static to proto

f(rp, s);

break;

default: // object to object

f(r, s);

}

return r;

};

}, "@VERSION@");

YUI.add("object", function(Y) {

/**

Y.Object = function(o) {

var F = function() {};

F.prototype = o;

return new F();

};

var O = Y.Object, L = Y.Lang;

/**

O.owns = function(o, p) {

return (o && o.hasOwnProperty) ? o.hasOwnProperty(p) : false;

};

/**

O.keys = function(o) {

var a=[], i;

for (i in o) {

if (O.owns(o, i)) {

a.push(i);

}

}

return a;

};

/**

O.each = function (o, f, c, proto) {

var s = c || Y;

for (var i in o) {

if (proto || O.owns(o, i)) {

f.call(s, o[i], i, o);

}

}

return Y;

};

}, "@VERSION@");

YUI.add("ua", function(Y) {

/**

Y.UA = function() {

var o={

/**

ie:0,

/**

opera:0,

/**

gecko:0,

/**

webkit:0,

/**

mobile: null

};

var ua=navigator.userAgent, m;

// 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

}

}

}

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;

}();

}, "@VERSION@");

YUI.add("later", function(Y) {

var L = Y.Lang;

/**

L.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.fail("method undefined");

}

if (!L.isArray(d)) {

d = [data];

}

f = function() {

m.apply(o, d);

};

r = (periodic) ? setInterval(f, when) : setTimeout(f, when);

return {

interval: periodic,

cancel: function() {

if (this.interval) {

clearInterval(r);

} else {

clearTimeout(r);

}

}

};

};

}, "@VERSION@");

YUI.add("get", function(Y) {

var ua=Y.UA,

L=Y.Lang;

Y.Get = function() {

/**

var queues={},

/**

qidx=0,

/**

nidx=0,

// ridx=0,

// sandboxFrame=null,

/**

purging=false;

/**

var _node = function(type, attr, win) {

var w = win || Y.config.win, d=w.document, n=d.createElement(type);

for (var i in attr) {

if (attr[i] && Y.Object.owns(attr, i)) {

n.setAttribute(i, attr[i]);

}

}

return n;

};

/**

var _linkNode = function(url, win, charset) {

var c = charset || "utf-8";

return _node("link", {

"id": "yui__dyn_" + (nidx++),

"type": "text/css",

"charset": c,

"rel": "stylesheet",

"href": url

}, win);

};

/**

var _scriptNode = function(url, win, charset) {

var c = charset || "utf-8";

return _node("script", {

"id": "yui__dyn_" + (nidx++),

"type": "text/javascript",

"charset": c,

"src": url

}, win);

};

/*

var _fail = function(id, msg) {

Y.log("get failure: " + msg, "warn", "Get");

var q = queues[id];

// execute failure callback

if (q.onFailure) {

var sc=q.context || q;

q.onFailure.call(sc, _returnData(q, msg));

}

};

var _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;

};

/**

var _purge = function(tId) {

var q=queues[tId];

if (q) {

var n=q.nodes, l=n.length, d=q.win.document,

h=d.getElementsByTagName("head")[0];

if (q.insertBefore) {

var s = _get(q.insertBefore, tId);

if (s) {

h = s.parentNode;

}

}

for (var i=0; i<l; i=i+1) {

h.removeChild(n[i]);

}

}

q.nodes = [];

};

/**

var _returnData = function(q, msg) {

return {

tId: q.tId,

win: q.win,

data: q.data,

nodes: q.nodes,

msg: msg,

purge: function() {

_purge(this.tId);

}

};

};

/**

var _finish = function(id) {

Y.log("Finishing transaction " + id);

var q = queues[id];

q.finished = true;

if (q.aborted) {

var msg = "transaction " + id + " was aborted";

_fail(id, msg);

return;

}

// execute success callback

if (q.onSuccess) {

var sc=q.context || q;

q.onSuccess.call(sc, _returnData(q));

}

};

/**

var _timeout = function(id) {

Y.log("Get utility timeout " + id);

var q = queues[id];

if (q.onTimeout) {

var sc=q.context || q;

q.onTimeout.call(sc, _returnData(q));

}

};

/**

var _next = function(id, loaded) {

Y.log("_next: " + id + ", loaded: " + loaded, "info", "Get");

var q = queues[id];

if (q.timer) {

// Y.log('cancel timer');

q.timer.cancel();

}

if (q.aborted) {

var 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;

}

}

var w=q.win, d=w.document, h=d.getElementsByTagName("head")[0], n;

if (q.url.length === 0) {

_finish(id);

return;

}

var url = q.url[0];

Y.log("attempting to load " + url, "info", "Get");

if (q.timeout) {

// Y.log('create timer');

q.timer = L.later(q.timeout, q, _timeout, id);

}

if (q.type === "script") {

n = _scriptNode(url, w, q.charset);

} else {

n = _linkNode(url, w, q.charset);

}

// 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'

if (q.insertBefore) {

var s = _get(q.insertBefore, id);

if (s) {

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

}

};

/**

var _autoPurge = function() {

if (purging) {

return;

}

purging = true;

for (var i in queues) {

if (queues.hasOwnProperty(i)) {

var q = queues[i];

if (q.autopurge && q.finished) {

_purge(q.tId);

delete queues[i];

}

}

}

purging = false;

};

/**

var _queue = function(type, url, opts) {

var id = "q" + (qidx++);

opts = opts || {};

if (qidx % Y.Get.PURGE_THRESH === 0) {

_autoPurge();

}

queues[id] = Y.merge(opts, {

tId: id,

type: type,

url: url,

finished: false,

nodes: []

});

var 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;

L.later(0, q, _next, id);

return {

tId: id

};

};

/**

var _track = function(type, n, id, url, win, qlength, trackfn) {

var f = trackfn || _next;

// IE supports the readystatechange event for script and css nodes

if (ua.ie) {

n.onreadystatechange = function() {

var rs = this.readyState;

if ("loaded" === rs || "complete" === rs) {

Y.log(id + " onload " + url, "info", "Get");

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

};

}

};

return {

/**

PURGE_THRESH: 20,

/**

_finalize: function(id) {

Y.log(id + " finalized ", "info", "Get");

L.later(0, null, _finish, id);

},

/**

abort: function(o) {

var id = (L.isString(o)) ? o : o.tId;

var q = queues[id];

if (q) {

Y.log("Aborting " + id, "info", "Get");

q.aborted = true;

}

},

/**

script: function(url, opts) {

return _queue("script", url, opts);

},

/**

css: function(url, opts) {

return _queue("css", url, opts);

}

};

}();

}, "@VERSION@");

YUI.add("loader", function(Y) {

var BASE = 'base',

CSS = 'css',

JS = 'js',

PKG = 'pkg',

ANIMATION = 'animation',

RESET = 'reset',

FONTS = 'fonts',

GRIDS = 'grids',

DRAGDROP = 'dragdrop',

JSON = 'json',

VERSION = '@VERSION@',

ROOT = VERSION + '/build/';

Y.Env.meta = {

version: VERSION,

root: ROOT,

base: 'http://yui.yahooapis.com/' + ROOT,

comboBase: 'http://yui.yahooapis.com/combo?',

modules: {

basecss: {

type: CSS,

after: [RESET, FONTS, GRIDS],

path: 'base/base.css'

},

fonts: {

type: CSS

},

grids: {

type: CSS,

requires: [FONTS],

optional: [RESET]

},

log: {

optional: [DRAGDROP],

path: 'log/logreader-min.js',

skinnable: 1

},

reset: {

type: CSS

},

'reset-fonts-grids': {

type: CSS,

path: 'reset-fonts-grids/reset-fonts-grids.css',

supersedes: [RESET, FONTS, GRIDS, 'reset-fonts'],

rollup: 4

},

'reset-fonts': {

type: CSS,

path: 'reset-fonts/reset-fonts.css',

supersedes: [RESET, FONTS],

rollup: 2

},

animation: {

requires: ['base']

},

attribute: {

requires: ['event']

},

base: {

requires: ['attribute']

},

classnamemanager: { },

compat: { },

cookie: { },

css: { },

'dd-ddm-base': {

path: 'dd/dd-ddm-base-min.js',

requires: ['node', BASE]

},

'dd-ddm':{

path: 'dd/dd-ddm-min.js',

requires: ['dd-ddm-base']

},

'dd-ddm-drop':{

path: 'dd/dd-ddm-drop-min.js',

requires: ['dd-ddm']

},

'dd-drag':{

path: 'dd/dd-drag-min.js',

requires: ['dd-ddm-base']

},

'dd-drop':{

path: 'dd/dd-drop-min.js',

requires: ['dd-ddm-drop']

},

'dd-proxy':{

path: 'dd/dd-proxy-min.js',

requires: ['dd-drag']

},

'dd-constrain':{

path: 'dd/dd-constrain-min.js',

requires: ['dd-drag', 'dd-proxy']

},

'dd-plugin':{

path: 'dd/dd-plugin-min.js',

requires: ['dd-drag'],

optional: ['dd-constrain', 'dd-proxy']

},

'dd-drop-plugin':{

path: 'dd/dd-drop-plugin-min.js',

requires: ['dd-drop']

},

'dd-drag-all':{

path: 'dd/dd-drag-all-min.js',

supersedes: ['dd-ddm-base', 'dd-ddm', 'dd-drag', 'dd-proxy', 'dd-constrain', 'dd-plugin', 'dd-drag-core', 'dd-drag-proxy']

},

'dd-dragdrop-all':{

path: 'dd/dd-dragdrop-all-min.js',

supersedes: ['dd-ddm-base', 'dd-ddm', 'dd-ddm-drop', 'dd-drag', 'dd-proxy', 'dd-constrain', 'dd-plugin', 'dd-drop', 'dd-drop-plugin', 'dd-drag-core', 'dd-drag-proxy']

},

'dd-drop-core':{

path: 'dd/dd-drop-core-min.js',

supersedes: ['dd-ddm-drop', 'dd-drop', 'dd-plugin-drop']

},

'dd-drag-core':{

path: 'dd/dd-drag-core-min.js',

supersedes: ['dd-ddm-base', 'dd-ddm', 'dd-drag', 'dd-plugin']

},

'dd-drag-proxy':{

path: 'dd/dd-drag-proxy-min.js',

supersedes: ['dd-ddm-base', 'dd-ddm', 'dd-drag', 'dd-proxy', 'dd-plugin']

},

dom: { },

dump: { },

event: {

requires: ['oop']

},

io: { },

'json-parse': {

path: 'json/json-parse-min.js'

},

'json-stringify': {

path: 'json/json-stringify-min.js'

},

json: {

supersedes: ['json-parse', 'json-stringify']

},

logreader: {

requires: ['css']

},

node: {

requires: ['event', 'dom']

},

oop: { },

profiler: { },

queue: { },

substitute: {

optional: ['dump']

},

yuitestcore: {

path: 'yuitest/yuitest_core-min.js'

},

yuitest: {

requires: ['log'],

// skinnable: 1,

supersedes: ['yuitestcore']

}

}

};

var L=Y.Lang, env=Y.Env,

PROV = "_provides", SUPER = "_supersedes",

REQ = "expanded";

var _Y = {

// dupsAllowed: {'yahoo': true, 'get': true},

dupsAllowed: {},

/*

// info: '@yuiinfo@',

info: Y.Env.meta

};

Y.Loader = function(o) {

/**

this._internalCallback = null;

/**

this._useYahooListener = false;

/*

// this.onSuccess = null;

/*

// this.onFailure = Y.log;

/*

// this.onProgress = null;

/**

this.context = Y;

/**

this.data = null;

/**

this.insertBefore = null;

/**

this.charset = null;

/**

this.base = _Y.info.base;

/**

this.comboBase = _Y.info.comboBase;

/**

this.combine = false;

/**

this.ignoreRegistered = false;

/**

this.root = _Y.info.root;

/**

this.timeout = 0;

/**

this.ignore = null;

/**

this.force = null;

/**

this.allowRollup = true;

/**

this.filter = null;

/**

this.required = {};

/**

// this.moduleInfo = Y.merge(_Y.info.moduleInfo);

this.moduleInfo = {};

var defaults = _Y.info.modules;

for (var i in defaults) {

if (defaults.hasOwnProperty(i)) {

this._internal = true;

this.addModule(defaults[i], i);

this._internal = false;

}

}

/**

this.rollups = null;

/**

this.loadOptional = false;

/**

this.sorted = [];

/**

this.loaded = {};

/**

this.dirty = true;

/**

this.inserted = {};

this.skipped = {};

// Y.on('yui:load', this.loadNext, this);

this._config(o);

};

Y.Loader.prototype = {

FILTERS: {

RAW: {

'searchExp': "-min\\.js",

'replaceStr': ".js"

},

DEBUG: {

'searchExp': "-min\\.js",

'replaceStr': "-debug.js"

}

},

_config: function(o) {

// apply config values

if (o) {

for (var i in o) {

if (o.hasOwnProperty(i)) {

if (i == "require") {

this.require(o[i]);

// support the old callback syntax

} else if (i.indexOf('on') === 0) {

this.subscribe(i.substr(2).toLowerCase(), o[i], o.context || this);

} else {

this[i] = o[i];

}

}

}

}

// fix filter

var f = this.filter;

if (L.isString(f)) {

f = f.toUpperCase();

// the logger must be available in order to use the debug

// versions of the library

if (f === "DEBUG") {

this.require("log");

}

// hack to handle a a bug where LogWriter is being instantiated

// at load time, and the loader has no way to sort above it

// at the moment.

if (!Y.LogWriter) {

Y.LogWriter = function() {

return Y;

};

}

this.filter = this.FILTERS[f];

}

},

/** Add a new module to the component metadata.

addModule: function(o, name) {

o.name = o.name || name;

if (!o || !o.name) {

return false;

}

if (!o.type) {

o.type = JS;

}

if (!o.path && !o.fullpath) {

o.path = name + "/" + name + "-min." + o.type;

}

o.ext = ('ext' in o) ? o.ext : (this._internal) ? false : true;

o.requires = o.requires || [];

this.moduleInfo[name] = o;

this.dirty = true;

//Y.log('New module ' + name);

return o;

},

/**

require: function(what) {

var a = (typeof what === "string") ? arguments : what;

this.dirty = true;

//OU.appendArray(this.required, a);

Y.mix(this.required, Y.Array.hash(a));

},

/**

getRequires: function(mod) {

if (!mod) {

// Y.log('getRequires, no module');

return [];

}

if (!this.dirty && mod.expanded) {

// Y.log('already expanded');

return mod.expanded;

}

var i, d=[], r=mod.requires, o=mod.optional,

info=this.moduleInfo, m, j, add;

for (i=0; i<r.length; i=i+1) {

// Y.log(mod.name + ' requiring ' + r[i]);

d.push(r[i]);

m = this.getModule(r[i]);

// AU.appendArray(d, this.getRequires(m));

// d.concat(this.getRequires(m));

// Y.log(d);

add = this.getRequires(m);

for (j=0;j<add.length;j=j+1) {

d.push(add[j]);

}

}

// get the requirements from superseded modules, if any

r=mod.supersedes;

if (r) {

for (i=0; i<r.length; i=i+1) {

// Y.log(mod.name + ' requiring ' + r[i]);

d.push(r[i]);

m = this.getModule(r[i]);

// AU.appendArray(d, this.getRequires(m));

// d.concat(this.getRequires(m));

// Y.log(d);

add = this.getRequires(m);

for (j=0;j<add.length;j=j+1) {

d.push(add[j]);

}

}

}

if (o && this.loadOptional) {

for (i=0; i<o.length; i=i+1) {

d.push(o[i]);

add = this.getRequires(info[o[i]]);

for (j=0;j<add.length;j=j+1) {

d.push(add[j]);

}

}

}

// Y.log(d);

// mod.expanded = AU.uniq(d);

mod.expanded = Y.Object.keys(Y.Array.hash(d));

// Y.log(mod.expanded);

return mod.expanded;

},

/**

getProvides: function(name, notMe) {

var addMe = !(notMe), ckey = (addMe) ? PROV : SUPER,

m = this.getModule(name), o = {};

if (!m) {

return o;

}

if (m[ckey]) {

return m[ckey];

}

var s = m.supersedes, done={}, me = this;

// use worker to break cycles

var add = function(mm) {

if (!done[mm]) {

// Y.log(name + ' provides worker trying: ' + mm);

done[mm] = true;

// we always want the return value normal behavior

// (provides) for superseded modules.

Y.mix(o, me.getProvides(mm));

}

// else {

// Y.log(name + ' provides worker skipping done: ' + mm);

// }

};

// calculate superseded modules

if (s) {

for (var i=0; i<s.length; i=i+1) {

add(s[i]);

}

}

// supersedes cache

m[SUPER] = o;

// provides cache

m[PROV] = Y.merge(o);

m[PROV][name] = true;

return m[ckey];

},

/**

calculate: function(o) {

if (o || this.dirty) {

this._config(o);

this._setup();

this._explode();

if (this.allowRollup) {

this._rollup();

}

this._reduce();

this._sort();

// Y.log("after calculate: " + this.sorted);

this.dirty = false;

}

},

/**

_setup: function() {

var info = this.moduleInfo, name, i, j;

var l = Y.merge(this.inserted); // shallow clone

// available modules

if (!this.ignoreRegistered) {

Y.mix(l, YUI.Env.mods);

}

// Y.log("Already loaded stuff: " + L.dump(l, 0));

// add the ignore list to the list of loaded packages

if (this.ignore) {

// OU.appendArray(l, this.ignore);

Y.mix(l, Y.Array.hash(this.ignore));

}

// remove modules on the force list from the loaded list

if (this.force) {

for (i=0; i<this.force.length; i=i+1) {

if (this.force[i] in l) {

delete l[this.force[i]];

}

}

}

// expand the list to include superseded modules

for (j in l) {

// Y.log("expanding: " + j);

if (Y.Object.owns(l, j)) {

Y.mix(l, this.getProvides(j));

}

}

// Y.log("loaded expanded: " + L.dump(l, 0));

this.loaded = l;

},

/**

_explode: function() {

var r=this.required, i, mod;

for (i in r) {

if (r.hasOwnProperty(i)) {

mod = this.getModule(i);

// Y.log('exploding ' + i);

var req = this.getRequires(mod);

if (req) {

// Y.log('via explode: ' + req);

Y.mix(r, Y.Array.hash(req));

}

}

}

},

getModule: function(name) {

var m = this.moduleInfo[name];

// create the default module

// if (!m) {

// Y.log('Module does not exist: ' + name + ', creating with defaults');

// m = this.addModule({ext: false}, name);

// }

return m;

},

/**

_rollup: function() {

var i, j, m, s, rollups={}, r=this.required, roll,

info = this.moduleInfo;

// find and cache rollup modules

if (this.dirty || !this.rollups) {

for (i in info) {

if (info.hasOwnProperty(i)) {

m = this.getModule(i);

// if (m && m.rollup && m.supersedes) {

if (m && m.rollup) {

rollups[i] = m;

}

}

}

this.rollups = rollups;

}

// make as many passes as needed to pick up rollup rollups

for (;;) {

var rolled = false;

// go through the rollup candidates

for (i in rollups) {

// there can be only one

if (!r[i] && !this.loaded[i]) {

m =this.getModule(i); s = m.supersedes ||[]; roll=false;

if (!m.rollup) {

continue;

}

var c=0;

// check the threshold

for (j=0;j<s.length;j=j+1) {

// if the superseded module is loaded, we can't load the rollup

if (this.loaded[s[j]] && (!_Y.dupsAllowed[s[j]])) {

roll = false;

break;

// increment the counter if this module is required. if we are

// beyond the rollup threshold, we will use the rollup module

} else if (r[s[j]]) {

c++;

roll = (c >= m.rollup);

if (roll) {

// Y.log("over thresh " + c + ", " + L.dump(r));

break;

}

}

}

if (roll) {

// Y.log("rollup: " + i + ", " + L.dump(this, 1));

// add the rollup

r[i] = true;

rolled = true;

// expand the rollup's dependencies

this.getRequires(m);

}

}

}

// if we made it here w/o rolling up something, we are done

if (!rolled) {

break;

}

}

},

/**

_reduce: function() {

var i, j, s, m, r=this.required;

for (i in r) {

// remove if already loaded

if (i in this.loaded) {

delete r[i];

// remove anything this module supersedes

} else {

m = this.getModule(i);

s = m && m.supersedes;

if (s) {

for (j=0; j<s.length; j=j+1) {

if (s[j] in r) {

delete r[s[j]];

}

}

}

}

}

},

_onSuccess: function() {

this._pushEvents();

Y._attach(this.sorted);

for (var i in this.skipped) {

delete this.inserted[i];

}

this.skipped = {};

// this.fire('success', {

// data: this.data

// });

var f = this.onSuccess;

if (f) {

f.call(this.context, {

data: this.data

});

}

},

_onFailure: function(msg) {

Y._attach(this.sorted);

// this.fire('failure', {

// msg: 'operation failed: ' + msg,

// data: this.data

// });

var f = this.onFailure;

if (f) {

f.call(this.context, {

msg: 'operation failed: ' + msg,

data: this.data

});

}

},

_onTimeout: function(msg) {

Y._attach(this.sorted);

// this.fire('timeout', {

// data: this.data

// });

var f = this.onTimeout;

if (f) {

f.call(this.context, {

data: this.data

});

}

},

/**

_sort: function() {

// create an indexed list

var s=Y.Object.keys(this.required), info=this.moduleInfo, loaded=this.loaded,

me = this;

// returns true if b is not loaded, and is required

// directly or by means of modules it supersedes.

var requires = function(aa, bb) {

var mm=info[aa];

if (loaded[bb] || !mm) {

return false;

}

var ii, rr = mm.expanded,

after = mm.after, other=info[bb];

// check if this module requires the other directly

if (rr && Y.Array.indexOf(rr, bb) > -1) {

return true;

}

// check if this module should be sorted after the other

if (after && Y.Array.indexOf(after, bb) > -1) {

return true;

}

// check if this module requires one the other supersedes

var ss=info[bb] && info[bb].supersedes;

if (ss) {

for (ii=0; ii<ss.length; ii=ii+1) {

if (requires(aa, ss[ii])) {

return true;

}

}

}

// external css files should be sorted below yui css

if (mm.ext && mm.type == CSS && (!other.ext)) {

return true;

}

return false;

};

// pointer to the first unsorted item

var p=0;

// keep going until we make a pass without moving anything

for (;;) {

var l=s.length, a, b, j, k, moved=false;

// start the loop after items that are already sorted

for (j=p; j<l; j=j+1) {

// check the next module on the list to see if its

// dependencies have been met

a = s[j];

// check everything below current item and move if we

// find a requirement for the current item

for (k=j+1; k<l; k=k+1) {

if (requires(a, s[k])) {

// extract the dependency so we can move it up

b = s.splice(k, 1);

// insert the dependency above the item that

// requires it

s.splice(j, 0, b[0]);

moved = true;

break;

}

}

// jump out of loop if we moved something

if (moved) {

break;

// this item is sorted, move our pointer and keep going

} else {

p = p + 1;

}

}

// when we make it here and moved is false, we are

// finished sorting

if (!moved) {

break;

}

}

this.sorted = s;

},

/**

insert: function(o, type) {

// if (o) {

// Y.log("insert: " + L.dump(o, 1) + ", " + type);

// } else {

// Y.log("insert: " + this.toString() + ", " + type);

// }

// build the dependency list

this.calculate(o);

if (!type) {

// Y.log("trying to load css first");

var self = this;

this._internalCallback = function() {

self._internalCallback = null;

self.insert(null, JS);

};

this.insert(null, CSS);

return;

}

// set a flag to indicate the load has started

this._loading = true;

// flag to indicate we are done with the combo service

// and any additional files will need to be loaded

// individually

this._combineComplete = false;

// keep the loadType (js, css or undefined) cached

this.loadType = type;

// start the load

this.loadNext();

},

/**

loadNext: function(mname) {

// It is possible that this function is executed due to something

// else one the page loading a YUI module. Only react when we

// are actively loading something

if (!this._loading) {

return;

}

var s, len, i, m, url, self=this;

if (this.combine && !this._combineComplete) {

this._combining = [];

s=this.sorted;

len=s.length;

url=this.comboBase;

for (i=0; i<len; i=i+1) {

m = this.getModule(s[i]);

// Do not try to combine non-yui JS

if (m.type == JS && !m.ext) {

url += this.root + m.path;

if (i < len) {

url += '&';

}

this._combining.push(s[i]);

}

}

if (this._combining.length) {

var callback=function(o) {

Y.log('loading combo, just loaded' + o.data);

self._combineComplete = true;

var c=self._combining, len=c.length, i, m;

for (i=0; i<len; i=i+1) {

self.inserted[c[i]] = true;

}

self.loadNext(o.data);

};

// @TODO get rid of the redundant Get code

Y.Get.script(url, {

data: s[i],

onSuccess: callback,

onFailure: this._onFailure,

onTimeout: this._onTimeout,

insertBefore: this.insertBefore,

charset: this.charset,

timeout: this.timeout,

context: self

});

return;

} else {

this._combineComplete = true;

}

}

if (mname) {

// if the module that was just loaded isn't what we were expecting,

// continue to wait

if (mname !== this._loading) {

return;

}

Y.log("loadNext executing, just loaded " + mname);

// The global handler that is called when each module is loaded

// will pass that module name to this function. Storing this

// data to avoid loading the same module multiple times

this.inserted[mname] = true;

// this.fire('progress', {

// name: mname,

// data: this.data

// });

if (this.onProgress) {

this.onProgress.call(this.context, {

name: mname,

data: this.data

});

}

}

s=this.sorted;

len=s.length;

for (i=0; i<len; i=i+1) {

// this.inserted keeps track of what the loader has loaded.

// move on if this item is done.

if (s[i] in this.inserted) {

// Y.log(s[i] + " alread loaded ");

continue;

}

// Because rollups will cause multiple load notifications

// from Y, loadNext may be called multiple times for

// the same module when loading a rollup. We can safely

// skip the subsequent requests

if (s[i] === this._loading) {

Y.log("still loading " + s[i] + ", waiting");

return;

}

// log("inserting " + s[i]);

m = this.getModule(s[i]);

if (!m) {

var msg = "Undefined module " + s[i] + " skipped";

Y.log(msg, 'warn', 'Loader');

this.inserted[s[i]] = true;

this.skipped[s[i]] = true;

continue;

// this.fire('failure', {

// msg: msg,

// data: this.data

// });

}

// The load type is stored to offer the possibility to load

// the css separately from the script.

if (!this.loadType || this.loadType === m.type) {

this._loading = s[i];

Y.log("attempting to load " + s[i] + ", " + this.base);

var fn=(m.type === CSS) ? Y.Get.css : Y.Get.script,

onsuccess=function(o) {

// Y.log('loading next, just loaded' + o.data);

self.loadNext(o.data);

};

url=m.fullpath || this._url(m.path);

self=this;

fn(url, {

data: s[i],

onSuccess: onsuccess,

insertBefore: this.insertBefore,

charset: this.charset,

onFailure: this._onFailure,

onTimeout: this._onTimeout,

timeout: this.timeout,

context: self

});

return;

}

}

// we are finished

this._loading = null;

// internal callback for loading css first

if (this._internalCallback) {

// Y.log('loader internal');

var f = this._internalCallback;

this._internalCallback = null;

f.call(this);

// } else if (this.onSuccess) {

} else {

// Y.log('loader complete');

// call Y.use passing this instance. Y will use the sorted

// dependency list.

this._onSuccess();

}

},

/**

_pushEvents: function(ref) {

var r = ref || Y;

if (r.Event) {

r.Event._load();

}

},

/**

_url: function(path) {

var u = this.base || "", f=this.filter;

u = u + path;

if (f) {

// Y.log("filter: " + f + ", " + f.searchExp +

// ", " + f.replaceStr);

u = u.replace(new RegExp(f.searchExp), f.replaceStr);

}

// Y.log(u);

return u;

}

};

// Y.augment(Y.Loader, Y.Event.Target);

}, "@VERSION@");

(function() {

var min = ['log', 'lang', 'array', 'core'], core,

M = function(Y) {

var C = Y.config;

// apply the minimal required functionality

Y.use.apply(Y, min);

Y.log(Y.id + ' setup completing) .');

if (C.core) {

core = C.core;

} else {

core = ["object", "ua", "later"];

core.push(