mirror of
https://github.com/swc-project/swc.git
synced 2024-12-22 13:11:31 +03:00
4680 lines
171 KiB
JavaScript
4680 lines
171 KiB
JavaScript
void 0 !== YUI && (YUI._YUI = YUI);
|
|
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 = 'undefined' != typeof YUI_config && YUI_config;
|
|
if (instanceOf(Y, YUI) ? (Y._init(), YUI.GlobalConfig && Y.applyConfig(YUI.GlobalConfig), gconf && Y.applyConfig(gconf), l || Y._setup()) : Y = new YUI(), l) {
|
|
for(; i < l; i++)Y.applyConfig(args[i]);
|
|
Y._setup();
|
|
}
|
|
return Y.instanceOf = instanceOf, Y;
|
|
};
|
|
!function() {
|
|
var proto, prop1, VERSION = '3.12.0', BASE = 'http://yui.yahooapis.com/', DOC_LABEL = 'yui3-js-enabled', CSS_STAMP_EL = 'yui3-css-stamp', NOOP = function() {}, SLICE = Array.prototype.slice, APPLY_TO_AUTH = {
|
|
'io.xdrReady': 1,
|
|
'io.xdrResponse': 1,
|
|
'SWF.eventHandler': 1
|
|
}, hasWin = 'undefined' != typeof window, 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) {
|
|
el && el.addEventListener ? el.addEventListener(type, fn, capture) : el && el.attachEvent && el.attachEvent('on' + type, fn);
|
|
}, remove = function(el, type, fn, capture) {
|
|
if (el && el.removeEventListener) try {
|
|
el.removeEventListener(type, fn, capture);
|
|
} catch (ex) {}
|
|
else el && el.detachEvent && el.detachEvent('on' + type, fn);
|
|
}, handleLoad = function() {
|
|
YUI.Env.windowLoaded = !0, YUI.Env.DOMReady = !0, hasWin && remove(window, 'load', handleLoad);
|
|
}, getLoader = function(Y, o) {
|
|
var loader = Y.Env._loader, lCore = [
|
|
'loader-base'
|
|
], mods = YUI.Env.mods;
|
|
return loader ? (loader.ignoreRegistered = !1, loader.onEnd = null, loader.data = null, loader.required = [], loader.loadType = null) : (loader = new Y.Loader(Y.config), Y.Env._loader = loader), mods && mods.loader && (lCore = [].concat(lCore, YUI.Env.loaderExtras)), YUI.Env.core = Y.Array.dedupe([].concat(YUI.Env.core, lCore)), loader;
|
|
}, clobber = function(r, s) {
|
|
for(var i in s)s.hasOwnProperty(i) && (r[i] = s[i]);
|
|
}, ALREADY_DONE = {
|
|
success: !0
|
|
};
|
|
for(prop1 in docEl && -1 == docClass.indexOf(DOC_LABEL) && (docClass && (docClass += ' '), docClass += DOC_LABEL, docEl.className = docClass), VERSION.indexOf('@') > -1 && (VERSION = '3.5.0'), proto = {
|
|
applyConfig: function(o) {
|
|
o = o || NOOP;
|
|
var attr, name, config = this.config, mods = config.modules, groups = config.groups, aliases = config.aliases, loader = this.Env._loader;
|
|
for(name in o)o.hasOwnProperty(name) && (attr = o[name], mods && 'modules' == name ? clobber(mods, attr) : aliases && 'aliases' == name ? clobber(aliases, attr) : groups && 'groups' == name ? clobber(groups, attr) : 'win' == name ? (config[name] = attr && attr.contentWindow || attr, config.doc = config[name] ? config[name].document : null) : '_yuid' == name || (config[name] = attr));
|
|
loader && loader._config(o);
|
|
},
|
|
_config: function(o) {
|
|
this.applyConfig(o);
|
|
},
|
|
_init: function() {
|
|
var filter1, el, prop, Y = this, G_ENV = YUI.Env, Env = Y.Env;
|
|
if (Y.version = VERSION, !Env) {
|
|
if (Y.Env = {
|
|
core: [
|
|
'get',
|
|
'features',
|
|
'intl-base',
|
|
'yui-log',
|
|
'yui-later',
|
|
'loader-base',
|
|
'loader-rollup',
|
|
'loader-yui3'
|
|
],
|
|
loaderExtras: [
|
|
'loader-rollup',
|
|
'loader-yui3'
|
|
],
|
|
mods: {},
|
|
versions: {},
|
|
base: BASE,
|
|
cdn: BASE + VERSION + '/build/',
|
|
_idx: 0,
|
|
_used: {},
|
|
_attached: {},
|
|
_missed: [],
|
|
_yidx: 0,
|
|
_uidx: 0,
|
|
_guidp: 'y',
|
|
_loaded: {},
|
|
_BASE_RE: /(?:\?(?:[^&]*&)*([^&]*))?\b(simpleyui|yui(?:-\w+)?)\/\2(?:-(min|debug))?\.js/,
|
|
parseBasePath: function(src, pattern) {
|
|
var path, filter, match = src.match(pattern);
|
|
return match && (path = RegExp.leftContext || src.slice(0, src.indexOf(match[0])), filter = match[3], match[1] && (path += '?' + match[1]), path = {
|
|
filter: filter,
|
|
path: path
|
|
}), path;
|
|
},
|
|
getBase: G_ENV && G_ENV.getBase || function(pattern) {
|
|
var parsed, i, len, src, nodes = doc && doc.getElementsByTagName('script') || [], path = Env.cdn;
|
|
for(i = 0, len = nodes.length; i < len; ++i)if ((src = nodes[i].src) && (parsed = Y.Env.parseBasePath(src, pattern))) {
|
|
filter1 = parsed.filter, path = parsed.path;
|
|
break;
|
|
}
|
|
return path;
|
|
}
|
|
}, (Env = Y.Env)._loaded[VERSION] = {}, G_ENV && Y !== YUI) Env._yidx = ++G_ENV._yidx, Env._guidp = ('yui_' + VERSION + '_' + Env._yidx + '_' + time).replace(/[^a-z0-9_]+/g, '_');
|
|
else if (YUI._YUI) {
|
|
for(prop in G_ENV = YUI._YUI.Env, Env._yidx += G_ENV._yidx, Env._uidx += G_ENV._uidx, G_ENV)prop in Env || (Env[prop] = G_ENV[prop]);
|
|
delete YUI._YUI;
|
|
}
|
|
Y.id = Y.stamp(Y), instances[Y.id] = Y;
|
|
}
|
|
Y.constructor = YUI, Y.config = Y.config || {
|
|
bootstrap: !0,
|
|
cacheUse: !0,
|
|
debug: !0,
|
|
doc: doc,
|
|
fetchCSS: !0,
|
|
throwFail: !0,
|
|
useBrowserConsole: !0,
|
|
useNativeES5: !0,
|
|
win: win,
|
|
global: Function('return this')()
|
|
}, doc && !doc.getElementById(CSS_STAMP_EL) ? ((el = doc.createElement('div')).innerHTML = '<div id="' + CSS_STAMP_EL + '" style="position: absolute !important; visibility: hidden !important"></div>', YUI.Env.cssStampEl = el.firstChild, doc.body ? doc.body.appendChild(YUI.Env.cssStampEl) : docEl.insertBefore(YUI.Env.cssStampEl, docEl.firstChild)) : doc && doc.getElementById(CSS_STAMP_EL) && !YUI.Env.cssStampEl && (YUI.Env.cssStampEl = doc.getElementById(CSS_STAMP_EL)), Y.config.lang = Y.config.lang || 'en-US', Y.config.base = YUI.config.base || Y.Env.getBase(Y.Env._BASE_RE), filter1 && 'mindebug'.indexOf(filter1) || (filter1 = 'min'), filter1 = filter1 ? '-' + filter1 : filter1, Y.config.loaderPath = YUI.config.loaderPath || 'loader/loader' + filter1 + '.js';
|
|
},
|
|
_setup: function() {
|
|
var i, core = [], mods = YUI.Env.mods, extras = this.config.core || [].concat(YUI.Env.core);
|
|
for(i = 0; i < extras.length; i++)mods[extras[i]] && core.push(extras[i]);
|
|
this._attach([
|
|
'yui-base'
|
|
]), this._attach(core), this.Loader && getLoader(this);
|
|
},
|
|
applyTo: function(id, method, args) {
|
|
if (!(method in APPLY_TO_AUTH)) return this.log(method + ': applyTo not allowed', 'warn', 'yui'), null;
|
|
var nest, m, i, instance = instances[id];
|
|
if (instance) {
|
|
for(i = 0, nest = method.split('.'), m = instance; i < nest.length; i += 1)(m = m[nest[i]]) || this.log('applyTo not found: ' + method, 'warn', 'yui');
|
|
return m && m.apply(instance, args);
|
|
}
|
|
return null;
|
|
},
|
|
add: function(name, fn, version, details) {
|
|
details = details || {};
|
|
var loader, inst, i, env = YUI.Env, mod = {
|
|
name: name,
|
|
fn: fn,
|
|
version: version,
|
|
details: details
|
|
}, applied = {}, versions = env.versions;
|
|
for(i in env.mods[name] = mod, versions[version] = versions[version] || {}, versions[version][name] = mod, instances)instances.hasOwnProperty(i) && !applied[(inst = instances[i]).id] && (applied[inst.id] = !0, (loader = inst.Env._loader) && (!loader.moduleInfo[name] || loader.moduleInfo[name].temp) && loader.addModule(details, name));
|
|
return this;
|
|
},
|
|
_attach: function(r, moot) {
|
|
var i, name, mod, details, req, use, after, j, loader, def, go, mods = YUI.Env.mods, aliases = YUI.Env.aliases, Y = this, cache = YUI.Env._renderedMods, loader = Y.Env._loader, done = Y.Env._attached, len = r.length, c = [];
|
|
for(i = 0; i < len; i++)if (mod = mods[name = r[i]], c.push(name), loader && loader.conditions[name]) for(j in loader.conditions[name])loader.conditions[name].hasOwnProperty(j) && (go = (def = loader.conditions[name][j]) && (def.ua && Y.UA[def.ua] || def.test && def.test(Y))) && c.push(def.name);
|
|
for(i = 0, len = (r = c).length; i < len; i++)if (!done[r[i]]) {
|
|
if (mod = mods[name = r[i]], aliases && aliases[name] && !mod) {
|
|
Y._attach(aliases[name]);
|
|
continue;
|
|
}
|
|
if (mod) {
|
|
for(j = 0, done[name] = !0; j < Y.Env._missed.length; j++)Y.Env._missed[j] === name && (Y.message('Found: ' + name + ' (was reported as missing earlier)', 'warn', 'yui'), Y.Env._missed.splice(j, 1));
|
|
if (loader && cache && cache[name] && cache[name].temp) {
|
|
for(j in loader.getRequires(cache[name]), req = [], loader.moduleInfo[name].expanded_map)loader.moduleInfo[name].expanded_map.hasOwnProperty(j) && req.push(j);
|
|
Y._attach(req);
|
|
}
|
|
if (req = (details = mod.details).requires, use = details.use, after = details.after, details.lang && (req = req || []).unshift('intl'), req) {
|
|
for(j = 0; j < req.length; j++)if (!done[req[j]]) {
|
|
if (!Y._attach(req)) return !1;
|
|
break;
|
|
}
|
|
}
|
|
if (after) {
|
|
for(j = 0; j < after.length; j++)if (!done[after[j]]) {
|
|
if (!Y._attach(after, !0)) return !1;
|
|
break;
|
|
}
|
|
}
|
|
if (mod.fn) {
|
|
if (Y.config.throwFail) mod.fn(Y, name);
|
|
else try {
|
|
mod.fn(Y, name);
|
|
} catch (e) {
|
|
return Y.error('Attach error: ' + name, e, name), !1;
|
|
}
|
|
}
|
|
if (use) {
|
|
for(j = 0; j < use.length; j++)if (!done[use[j]]) {
|
|
if (!Y._attach(use)) return !1;
|
|
break;
|
|
}
|
|
}
|
|
} else loader && loader.moduleInfo[name] && (mod = loader.moduleInfo[name], moot = !0), !moot && name && -1 === name.indexOf('skin-') && -1 === name.indexOf('css') && (Y.Env._missed.push(name), Y.Env._missed = Y.Array.dedupe(Y.Env._missed), Y.message('NOT loaded: ' + name, 'warn', 'yui'));
|
|
}
|
|
return !0;
|
|
},
|
|
_delayCallback: function(cb, until) {
|
|
var Y = this, mod = [
|
|
'event-base'
|
|
];
|
|
return 'load' === (until = Y.Lang.isObject(until) ? until : {
|
|
event: until
|
|
}).event && mod.push('event-synthetic'), function() {
|
|
var args = arguments;
|
|
Y._use(mod, function() {
|
|
Y.on(until.event, function() {
|
|
args[1].delayUntil = until.event, cb.apply(Y, args);
|
|
}, until.args);
|
|
});
|
|
};
|
|
},
|
|
use: function() {
|
|
var name, args = SLICE.call(arguments, 0), callback = args[args.length - 1], Y1 = this, i = 0, Env = Y1.Env, provisioned = !0;
|
|
if (Y1.Lang.isFunction(callback) ? (args.pop(), Y1.config.delayUntil && (callback = Y1._delayCallback(callback, Y1.config.delayUntil))) : callback = null, Y1.Lang.isArray(args[0]) && (args = args[0]), Y1.config.cacheUse) {
|
|
for(; name = args[i++];)if (!Env._attached[name]) {
|
|
provisioned = !1;
|
|
break;
|
|
}
|
|
if (provisioned) return args.length, Y1._notify(callback, ALREADY_DONE, args), Y1;
|
|
}
|
|
return Y1._loading ? (Y1._useQueue = Y1._useQueue || new Y1.Queue(), Y1._useQueue.add([
|
|
args,
|
|
callback
|
|
])) : Y1._use(args, function(Y, response) {
|
|
Y._notify(callback, response, args);
|
|
}), Y1;
|
|
},
|
|
_notify: function(callback, response, args) {
|
|
if (!response.success && this.config.loadErrorFn) this.config.loadErrorFn.call(this, this, callback, response, args);
|
|
else if (callback) {
|
|
if (this.Env._missed && this.Env._missed.length && (response.msg = 'Missing modules: ' + this.Env._missed.join(), response.success = !1), this.config.throwFail) callback(this, response);
|
|
else try {
|
|
callback(this, response);
|
|
} catch (e) {
|
|
this.error('use callback error', e, args);
|
|
}
|
|
}
|
|
},
|
|
_use: function(args, callback) {
|
|
this.Array || this._attach([
|
|
'yui-base'
|
|
]);
|
|
var len1, loader, handleBoot, i1, Y = this, G_ENV = YUI.Env, mods = G_ENV.mods, Env = Y.Env, used = Env._used, aliases = G_ENV.aliases, queue = G_ENV._loaderQueue, firstArg = args[0], YArray = Y.Array, config = Y.config, boot = config.bootstrap, missing = [], r = [], ret1 = !0, fetchCSS = config.fetchCSS, process = function(names, skip) {
|
|
var name, len, m, req, use, i = 0, a = [];
|
|
if (names.length) {
|
|
if (aliases) {
|
|
for(i = 0, len = names.length; i < len; i++)aliases[names[i]] && !mods[names[i]] ? a = [].concat(a, aliases[names[i]]) : a.push(names[i]);
|
|
names = a;
|
|
}
|
|
for(i = 0, len = names.length; i < len; i++)name = names[i], skip || r.push(name), !used[name] && (m = mods[name], req = null, use = null, m ? (used[name] = !0, req = m.details.requires, use = m.details.use) : G_ENV._loaded[VERSION][name] ? used[name] = !0 : missing.push(name), req && req.length && process(req), use && use.length && process(use, 1));
|
|
}
|
|
}, handleLoader = function(fromLoader) {
|
|
var redo, origMissing, response = fromLoader || {
|
|
success: !0,
|
|
msg: 'not dynamic'
|
|
}, ret = !0, data = response.data;
|
|
Y._loading = !1, data && (origMissing = missing, missing = [], r = [], process(data), (redo = missing.length) && [].concat(missing).sort().join() == origMissing.sort().join() && (redo = !1)), redo && data ? (Y._loading = !0, Y._use(missing, function() {
|
|
Y._attach(data) && Y._notify(callback, response, data);
|
|
})) : (data && (ret = Y._attach(data)), ret && Y._notify(callback, response, args)), Y._useQueue && Y._useQueue.size() && !Y._loading && Y._use.apply(Y, Y._useQueue.next());
|
|
};
|
|
if ('*' === firstArg) {
|
|
for(i1 in args = [], mods)mods.hasOwnProperty(i1) && args.push(i1);
|
|
return (ret1 = Y._attach(args)) && handleLoader(), Y;
|
|
}
|
|
return (mods.loader || mods['loader-base']) && !Y.Loader && Y._attach([
|
|
'loader' + (mods.loader ? '' : '-base')
|
|
]), boot && Y.Loader && args.length && ((loader = getLoader(Y)).require(args), loader.ignoreRegistered = !0, loader._boot = !0, loader.calculate(null, fetchCSS ? null : 'js'), args = loader.sorted, loader._boot = !1), process(args), (len1 = missing.length) && (len1 = (missing = YArray.dedupe(missing)).length), boot && len1 && Y.Loader ? (Y._loading = !0, (loader = getLoader(Y)).onEnd = handleLoader, loader.context = Y, loader.data = args, loader.ignoreRegistered = !1, loader.require(missing), loader.insert(null, fetchCSS ? null : 'js')) : boot && len1 && Y.Get && !Env.bootstrapped ? (Y._loading = !0, handleBoot = function() {
|
|
Y._loading = !1, queue.running = !1, Env.bootstrapped = !0, G_ENV._bootstrapping = !1, Y._attach([
|
|
'loader'
|
|
]) && Y._use(args, callback);
|
|
}, G_ENV._bootstrapping ? queue.add(handleBoot) : (G_ENV._bootstrapping = !0, Y.Get.script(config.base + config.loaderPath, {
|
|
onEnd: handleBoot
|
|
}))) : (ret1 = Y._attach(args)) && handleLoader(), Y;
|
|
},
|
|
namespace: function() {
|
|
for(var o, j, d, arg, a = arguments, i = 0; i < a.length; i++)if (o = this, (arg = a[i]).indexOf('.') > -1) for(j = 'YAHOO' == (d = arg.split('.'))[0] ? 1 : 0; j < d.length; j++)o[d[j]] = o[d[j]] || {}, o = o[d[j]];
|
|
else o[arg] = o[arg] || {}, o = o[arg];
|
|
return o;
|
|
},
|
|
log: NOOP,
|
|
message: NOOP,
|
|
dump: function(o) {
|
|
return '' + o;
|
|
},
|
|
error: function(msg, e, src) {
|
|
var ret;
|
|
if (this.config.errorFn && (ret = this.config.errorFn.apply(this, arguments)), ret) this.message(msg, 'error', '' + src);
|
|
else throw e || new Error(msg);
|
|
return this;
|
|
},
|
|
guid: function(pre) {
|
|
var id = this.Env._guidp + '_' + ++this.Env._uidx;
|
|
return pre ? pre + id : id;
|
|
},
|
|
stamp: function(o, readOnly) {
|
|
var uid;
|
|
if (!o) return o;
|
|
if (!(uid = o.uniqueID && o.nodeType && 9 !== o.nodeType ? o.uniqueID : 'string' == typeof o ? o : o._yuid) && (uid = this.guid(), !readOnly)) try {
|
|
o._yuid = uid;
|
|
} catch (e) {
|
|
uid = null;
|
|
}
|
|
return uid;
|
|
},
|
|
destroy: function() {
|
|
this.Event && this.Event._unload(), delete instances[this.id], delete this.Env, delete this.config;
|
|
}
|
|
}, YUI.prototype = proto, proto)proto.hasOwnProperty(prop1) && (YUI[prop1] = proto[prop1]);
|
|
YUI.applyConfig = function(o) {
|
|
o && (YUI.GlobalConfig && this.prototype.applyConfig.call(this, YUI.GlobalConfig), this.prototype.applyConfig.call(this, o), YUI.GlobalConfig = this.config);
|
|
}, YUI._init(), hasWin ? add(window, 'load', handleLoad) : handleLoad(), YUI.Env.add = add, YUI.Env.remove = remove, 'object' == typeof exports && (exports.YUI = YUI, YUI.setLoadHook = function(fn) {
|
|
YUI._getLoadHook = fn;
|
|
}, YUI._getLoadHook = null), YUI.Env[VERSION] = {};
|
|
}(), YUI.add('yui-base', function(Y, NAME) {
|
|
var L = Y.Lang || (Y.Lang = {}), STRING_PROTO = String.prototype, TOSTRING = Object.prototype.toString, TYPES = {
|
|
undefined: 'undefined',
|
|
number: 'number',
|
|
'boolean': 'boolean',
|
|
string: 'string',
|
|
'[object Function]': 'function',
|
|
'[object RegExp]': 'regexp',
|
|
'[object Array]': 'array',
|
|
'[object Date]': 'date',
|
|
'[object Error]': 'error'
|
|
}, SUBREGEX = /\{\s*([^|}]+?)\s*(?:\|([^}]*))?\s*\}/g, WHITESPACE = "\x09\x0A\x0B\x0C\x0D\x20\xA0\u1680\u180E\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200A\u2028\u2029\u202F\u205F\u3000\uFEFF", WHITESPACE_CLASS = "[\x09-\x0D\x20\xA0\u1680\u180E\u2000-\u200A\u2028\u2029\u202F\u205F\u3000\uFEFF]+", TRIM_LEFT_REGEX = new RegExp("^" + WHITESPACE_CLASS), TRIM_RIGHT_REGEX = new RegExp(WHITESPACE_CLASS + "$"), TRIMREGEX = new RegExp(TRIM_LEFT_REGEX.source + "|" + TRIM_RIGHT_REGEX.source, "g"), NATIVE_FN_REGEX = /\{\s*\[(?:native code|function)\]\s*\}/i;
|
|
L._isNative = function(fn) {
|
|
return !!(Y.config.useNativeES5 && fn && NATIVE_FN_REGEX.test(fn));
|
|
}, L.isArray = L._isNative(Array.isArray) ? Array.isArray : function(o) {
|
|
return 'array' === L.type(o);
|
|
}, L.isBoolean = function(o) {
|
|
return 'boolean' == typeof o;
|
|
}, L.isDate = function(o) {
|
|
return 'date' === L.type(o) && 'Invalid Date' !== o.toString() && !isNaN(o);
|
|
}, L.isFunction = function(o) {
|
|
return 'function' === L.type(o);
|
|
}, L.isNull = function(o) {
|
|
return null === o;
|
|
}, L.isNumber = function(o) {
|
|
return 'number' == typeof o && isFinite(o);
|
|
}, L.isObject = function(o, failfn) {
|
|
var t = typeof o;
|
|
return o && ('object' === t || !failfn && ('function' === t || L.isFunction(o))) || !1;
|
|
}, L.isString = function(o) {
|
|
return 'string' == typeof o;
|
|
}, L.isUndefined = function(o) {
|
|
return void 0 === o;
|
|
}, L.isValue = function(o) {
|
|
var t = L.type(o);
|
|
switch(t){
|
|
case 'number':
|
|
return isFinite(o);
|
|
case 'null':
|
|
case 'undefined':
|
|
return !1;
|
|
default:
|
|
return !!t;
|
|
}
|
|
}, L.now = Date.now || function() {
|
|
return new Date().getTime();
|
|
}, L.sub = function(s, o) {
|
|
return s.replace ? s.replace(SUBREGEX, function(match, key) {
|
|
return L.isUndefined(o[key]) ? match : o[key];
|
|
}) : s;
|
|
}, L.trim = L._isNative(STRING_PROTO.trim) && !WHITESPACE.trim() ? function(s) {
|
|
return s && s.trim ? s.trim() : s;
|
|
} : function(s) {
|
|
try {
|
|
return s.replace(TRIMREGEX, '');
|
|
} catch (e) {
|
|
return s;
|
|
}
|
|
}, L.trimLeft = L._isNative(STRING_PROTO.trimLeft) && !WHITESPACE.trimLeft() ? function(s) {
|
|
return s.trimLeft();
|
|
} : function(s) {
|
|
return s.replace(TRIM_LEFT_REGEX, '');
|
|
}, L.trimRight = L._isNative(STRING_PROTO.trimRight) && !WHITESPACE.trimRight() ? function(s) {
|
|
return s.trimRight();
|
|
} : function(s) {
|
|
return s.replace(TRIM_RIGHT_REGEX, '');
|
|
}, L.type = function(o) {
|
|
return TYPES[typeof o] || TYPES[TOSTRING.call(o)] || (o ? 'object' : 'null');
|
|
};
|
|
var Lang = Y.Lang, Native = Array.prototype, hasOwn = Object.prototype.hasOwnProperty;
|
|
function YArray(thing, startIndex, force) {
|
|
var len, result;
|
|
if (startIndex || (startIndex = 0), force || YArray.test(thing)) try {
|
|
return Native.slice.call(thing, startIndex);
|
|
} catch (ex) {
|
|
for(result = [], len = thing.length; startIndex < len; ++startIndex)result.push(thing[startIndex]);
|
|
return result;
|
|
}
|
|
return [
|
|
thing
|
|
];
|
|
}
|
|
function Queue() {
|
|
this._init(), this.add.apply(this, arguments);
|
|
}
|
|
Y.Array = YArray, YArray.dedupe = Lang._isNative(Object.create) ? function(array) {
|
|
var i, item, len, hash = Object.create(null), results = [];
|
|
for(i = 0, len = array.length; i < len; ++i)hash[item = array[i]] || (hash[item] = 1, results.push(item));
|
|
return results;
|
|
} : function(array) {
|
|
var i, item, len, hash = {}, results = [];
|
|
for(i = 0, len = array.length; i < len; ++i)item = array[i], hasOwn.call(hash, item) || (hash[item] = 1, results.push(item));
|
|
return results;
|
|
}, YArray.each = YArray.forEach = Lang._isNative(Native.forEach) ? function(array, fn, thisObj) {
|
|
return Native.forEach.call(array || [], fn, thisObj || Y), Y;
|
|
} : function(array, fn, thisObj) {
|
|
for(var i = 0, len = array && array.length || 0; i < len; ++i)i in array && fn.call(thisObj || Y, array[i], i, array);
|
|
return Y;
|
|
}, YArray.hash = function(keys, values) {
|
|
var i, len, hash = {}, vlen = values && values.length || 0;
|
|
for(i = 0, len = keys.length; i < len; ++i)i in keys && (hash[keys[i]] = !(vlen > i) || !(i in values) || values[i]);
|
|
return hash;
|
|
}, YArray.indexOf = Lang._isNative(Native.indexOf) ? function(array, value, from) {
|
|
return Native.indexOf.call(array, value, from);
|
|
} : function(array, value, from) {
|
|
var len = array.length;
|
|
for((from = ((from = +from || 0) > 0 || -1) * Math.floor(Math.abs(from))) < 0 && (from += len) < 0 && (from = 0); from < len; ++from)if (from in array && array[from] === value) return from;
|
|
return -1;
|
|
}, YArray.numericSort = function(a, b) {
|
|
return a - b;
|
|
}, YArray.some = Lang._isNative(Native.some) ? function(array, fn, thisObj) {
|
|
return Native.some.call(array, fn, thisObj);
|
|
} : function(array, fn, thisObj) {
|
|
for(var i = 0, len = array.length; i < len; ++i)if (i in array && fn.call(thisObj, array[i], i, array)) return !0;
|
|
return !1;
|
|
}, YArray.test = function(obj) {
|
|
var result = 0;
|
|
if (Lang.isArray(obj)) result = 1;
|
|
else if (Lang.isObject(obj)) try {
|
|
'length' in obj && !obj.tagName && !(obj.scrollTo && obj.document) && !obj.apply && (result = 2);
|
|
} catch (ex) {}
|
|
return result;
|
|
}, Queue.prototype = {
|
|
_init: function() {
|
|
this._q = [];
|
|
},
|
|
next: function() {
|
|
return this._q.shift();
|
|
},
|
|
last: function() {
|
|
return this._q.pop();
|
|
},
|
|
add: function() {
|
|
return this._q.push.apply(this._q, arguments), this;
|
|
},
|
|
size: function() {
|
|
return this._q.length;
|
|
}
|
|
}, Y.Queue = Queue, YUI.Env._loaderQueue = YUI.Env._loaderQueue || new Queue();
|
|
var hasOwn = Object.prototype.hasOwnProperty, isObject = Y.Lang.isObject;
|
|
Y.cached = function(source, cache, refetch) {
|
|
return cache || (cache = {}), function(arg) {
|
|
var key = arguments.length > 1 ? Array.prototype.join.call(arguments, '__') : String(arg);
|
|
return key in cache && (!refetch || cache[key] != refetch) || (cache[key] = source.apply(source, arguments)), cache[key];
|
|
};
|
|
}, Y.getLocation = function() {
|
|
var win = Y.config.win;
|
|
return win && win.location;
|
|
}, Y.merge = function() {
|
|
for(var key, obj, i = 0, len = arguments.length, result = {}; i < len; ++i)for(key in obj = arguments[i])hasOwn.call(obj, key) && (result[key] = obj[key]);
|
|
return result;
|
|
}, Y.mix = function(receiver, supplier, overwrite, whitelist, mode, merge) {
|
|
var alwaysOverwrite, exists, from, i, key, len, to;
|
|
if (!receiver || !supplier) return receiver || Y;
|
|
if (mode) {
|
|
if (2 === mode && Y.mix(receiver.prototype, supplier.prototype, overwrite, whitelist, 0, merge), from = 1 === mode || 3 === mode ? supplier.prototype : supplier, to = 1 === mode || 4 === mode ? receiver.prototype : receiver, !from || !to) return receiver;
|
|
} else from = supplier, to = receiver;
|
|
if (alwaysOverwrite = overwrite && !merge, whitelist) for(i = 0, len = whitelist.length; i < len; ++i)key = whitelist[i], hasOwn.call(from, key) && (exists = !alwaysOverwrite && key in to, merge && exists && isObject(to[key], !0) && isObject(from[key], !0) ? Y.mix(to[key], from[key], overwrite, null, 0, merge) : (overwrite || !exists) && (to[key] = from[key]));
|
|
else {
|
|
for(key in from)hasOwn.call(from, key) && (exists = !alwaysOverwrite && key in to, merge && exists && isObject(to[key], !0) && isObject(from[key], !0) ? Y.mix(to[key], from[key], overwrite, null, 0, merge) : (overwrite || !exists) && (to[key] = from[key]));
|
|
Y.Object._hasEnumBug && Y.mix(to, from, overwrite, Y.Object._forceEnum, mode, merge);
|
|
}
|
|
return receiver;
|
|
};
|
|
var UNDEFINED, Lang = Y.Lang, hasOwn = Object.prototype.hasOwnProperty, O = Y.Object = Lang._isNative(Object.create) ? function(obj) {
|
|
return Object.create(obj);
|
|
} : function() {
|
|
function F() {}
|
|
return function(obj) {
|
|
return F.prototype = obj, new F();
|
|
};
|
|
}(), forceEnum = O._forceEnum = [
|
|
'hasOwnProperty',
|
|
'isPrototypeOf',
|
|
'propertyIsEnumerable',
|
|
'toString',
|
|
'toLocaleString',
|
|
'valueOf'
|
|
], hasEnumBug = O._hasEnumBug = !({
|
|
valueOf: 0
|
|
}).propertyIsEnumerable('valueOf'), hasProtoEnumBug = O._hasProtoEnumBug = (function() {}).propertyIsEnumerable('prototype'), owns = O.owns = function(obj, key) {
|
|
return !!obj && hasOwn.call(obj, key);
|
|
};
|
|
O.hasKey = owns, O.keys = Lang._isNative(Object.keys) && !hasProtoEnumBug ? Object.keys : function(obj) {
|
|
if (!Lang.isObject(obj)) throw new TypeError('Object.keys called on a non-object');
|
|
var i, key, len, keys = [];
|
|
if (hasProtoEnumBug && 'function' == typeof obj) for(key in obj)owns(obj, key) && 'prototype' !== key && keys.push(key);
|
|
else for(key in obj)owns(obj, key) && keys.push(key);
|
|
if (hasEnumBug) for(i = 0, len = forceEnum.length; i < len; ++i)owns(obj, key = forceEnum[i]) && keys.push(key);
|
|
return keys;
|
|
}, O.values = function(obj) {
|
|
for(var keys = O.keys(obj), i = 0, len = keys.length, values = []; i < len; ++i)values.push(obj[keys[i]]);
|
|
return values;
|
|
}, O.size = function(obj) {
|
|
try {
|
|
return O.keys(obj).length;
|
|
} catch (ex) {
|
|
return 0;
|
|
}
|
|
}, O.hasValue = function(obj, value) {
|
|
return Y.Array.indexOf(O.values(obj), value) > -1;
|
|
}, O.each = function(obj, fn, thisObj, proto) {
|
|
var key;
|
|
for(key in obj)(proto || owns(obj, key)) && fn.call(thisObj || Y, obj[key], key, obj);
|
|
return Y;
|
|
}, O.some = function(obj, fn, thisObj, proto) {
|
|
var key;
|
|
for(key in obj)if ((proto || owns(obj, key)) && fn.call(thisObj || Y, obj[key], key, obj)) return !0;
|
|
return !1;
|
|
}, O.getValue = function(o, path) {
|
|
if (!Lang.isObject(o)) return UNDEFINED;
|
|
var i, p = Y.Array(path), l = p.length;
|
|
for(i = 0; o !== UNDEFINED && i < l; i++)o = o[p[i]];
|
|
return o;
|
|
}, O.setValue = function(o, path, val) {
|
|
var i, p = Y.Array(path), leafIdx = p.length - 1, ref = o;
|
|
if (leafIdx >= 0) {
|
|
for(i = 0; ref !== UNDEFINED && i < leafIdx; i++)ref = ref[p[i]];
|
|
if (ref === UNDEFINED) return UNDEFINED;
|
|
ref[p[i]] = val;
|
|
}
|
|
return o;
|
|
}, O.isEmpty = function(obj) {
|
|
return !O.keys(Object(obj)).length;
|
|
}, YUI.Env.parseUA = function(subUA) {
|
|
var m, numberify = function(s) {
|
|
var c = 0;
|
|
return parseFloat(s.replace(/\./g, function() {
|
|
return 1 == c++ ? '' : '.';
|
|
}));
|
|
}, win = Y.config.win, nav = win && win.navigator, o = {
|
|
ie: 0,
|
|
opera: 0,
|
|
gecko: 0,
|
|
webkit: 0,
|
|
safari: 0,
|
|
chrome: 0,
|
|
mobile: null,
|
|
air: 0,
|
|
phantomjs: 0,
|
|
ipad: 0,
|
|
iphone: 0,
|
|
ipod: 0,
|
|
ios: null,
|
|
android: 0,
|
|
silk: 0,
|
|
accel: !1,
|
|
webos: 0,
|
|
caja: nav && nav.cajaVersion,
|
|
secure: !1,
|
|
os: null,
|
|
nodejs: 0,
|
|
winjs: !!("undefined" != typeof Windows && Windows.System),
|
|
touchEnabled: !1
|
|
}, ua = subUA || nav && nav.userAgent, loc = win && win.location, href = loc && loc.href;
|
|
return o.userAgent = ua, o.secure = href && 0 === href.toLowerCase().indexOf('https'), ua && (/windows|win32/i.test(ua) ? o.os = 'windows' : /macintosh|mac_powerpc/i.test(ua) ? o.os = 'macintosh' : /android/i.test(ua) ? o.os = 'android' : /symbos/i.test(ua) ? o.os = 'symbos' : /linux/i.test(ua) ? o.os = 'linux' : /rhino/i.test(ua) && (o.os = 'rhino'), /KHTML/.test(ua) && (o.webkit = 1), /IEMobile|XBLWP7/.test(ua) && (o.mobile = 'windows'), /Fennec/.test(ua) && (o.mobile = 'gecko'), (m = ua.match(/AppleWebKit\/([^\s]*)/)) && m[1] && (o.webkit = numberify(m[1]), o.safari = o.webkit, /PhantomJS/.test(ua) && (m = ua.match(/PhantomJS\/([^\s]*)/)) && m[1] && (o.phantomjs = numberify(m[1])), / Mobile\//.test(ua) || /iPad|iPod|iPhone/.test(ua) ? (o.mobile = 'Apple', (m = ua.match(/OS ([^\s]*)/)) && m[1] && (m = numberify(m[1].replace('_', '.'))), o.ios = m, o.os = 'ios', o.ipad = o.ipod = o.iphone = 0, (m = ua.match(/iPad|iPod|iPhone/)) && m[0] && (o[m[0].toLowerCase()] = o.ios)) : ((m = ua.match(/NokiaN[^\/]*|webOS\/\d\.\d/)) && (o.mobile = m[0]), /webOS/.test(ua) && (o.mobile = 'WebOS', (m = ua.match(/webOS\/([^\s]*);/)) && m[1] && (o.webos = numberify(m[1]))), / Android/.test(ua) && (/Mobile/.test(ua) && (o.mobile = 'Android'), (m = ua.match(/Android ([^\s]*);/)) && m[1] && (o.android = numberify(m[1]))), /Silk/.test(ua) && ((m = ua.match(/Silk\/([^\s]*)\)/)) && m[1] && (o.silk = numberify(m[1])), o.android || (o.android = 2.34, o.os = 'Android'), /Accelerated=true/.test(ua) && (o.accel = !0))), (m = ua.match(/OPR\/(\d+\.\d+)/)) && m[1] ? o.opera = numberify(m[1]) : (m = ua.match(/(Chrome|CrMo|CriOS)\/([^\s]*)/)) && m[1] && m[2] ? (o.chrome = numberify(m[2]), o.safari = 0, 'CrMo' === m[1] && (o.mobile = 'chrome')) : (m = ua.match(/AdobeAIR\/([^\s]*)/)) && (o.air = m[0])), !o.webkit && (/Opera/.test(ua) ? ((m = ua.match(/Opera[\s\/]([^\s]*)/)) && m[1] && (o.opera = numberify(m[1])), (m = ua.match(/Version\/([^\s]*)/)) && m[1] && (o.opera = numberify(m[1])), /Opera Mobi/.test(ua) && (o.mobile = 'opera', (m = ua.replace('Opera Mobi', '').match(/Opera ([^\s]*)/)) && m[1] && (o.opera = numberify(m[1]))), (m = ua.match(/Opera Mini[^;]*/)) && (o.mobile = m[0])) : (m = ua.match(/MSIE ([^;]*)|Trident.*; rv:([0-9.]+)/)) && (m[1] || m[2]) ? o.ie = numberify(m[1] || m[2]) : (m = ua.match(/Gecko\/([^\s]*)/)) && (o.gecko = 1, (m = ua.match(/rv:([^\s\)]*)/)) && m[1] && (o.gecko = numberify(m[1]), /Mobile|Tablet/.test(ua) && (o.mobile = "ffos"))))), win && nav && !(o.chrome && o.chrome < 6) && (o.touchEnabled = "ontouchstart" in win || "msMaxTouchPoints" in nav && nav.msMaxTouchPoints > 0), subUA || ('object' == typeof process && process.versions && process.versions.node && (o.os = process.platform, o.nodejs = numberify(process.versions.node)), YUI.Env.UA = o), o;
|
|
}, Y.UA = YUI.Env.UA || YUI.Env.parseUA(), Y.UA.compareVersions = function(a, b) {
|
|
var aPart, aParts, bPart, bParts, i, len;
|
|
if (a === b) return 0;
|
|
for(i = 0, aParts = (a + '').split('.'), bParts = (b + '').split('.'), len = Math.max(aParts.length, bParts.length); i < len; ++i){
|
|
if (aPart = parseInt(aParts[i], 10), bPart = parseInt(bParts[i], 10), isNaN(aPart) && (aPart = 0), isNaN(bPart) && (bPart = 0), aPart < bPart) return -1;
|
|
if (aPart > bPart) return 1;
|
|
}
|
|
return 0;
|
|
}, YUI.Env.aliases = {
|
|
anim: [
|
|
"anim-base",
|
|
"anim-color",
|
|
"anim-curve",
|
|
"anim-easing",
|
|
"anim-node-plugin",
|
|
"anim-scroll",
|
|
"anim-xy"
|
|
],
|
|
"anim-shape-transform": [
|
|
"anim-shape"
|
|
],
|
|
app: [
|
|
"app-base",
|
|
"app-content",
|
|
"app-transitions",
|
|
"lazy-model-list",
|
|
"model",
|
|
"model-list",
|
|
"model-sync-rest",
|
|
"router",
|
|
"view",
|
|
"view-node-map"
|
|
],
|
|
attribute: [
|
|
"attribute-base",
|
|
"attribute-complex"
|
|
],
|
|
"attribute-events": [
|
|
"attribute-observable"
|
|
],
|
|
autocomplete: [
|
|
"autocomplete-base",
|
|
"autocomplete-sources",
|
|
"autocomplete-list",
|
|
"autocomplete-plugin"
|
|
],
|
|
axes: [
|
|
"axis-numeric",
|
|
"axis-category",
|
|
"axis-time",
|
|
"axis-stacked"
|
|
],
|
|
"axes-base": [
|
|
"axis-numeric-base",
|
|
"axis-category-base",
|
|
"axis-time-base",
|
|
"axis-stacked-base"
|
|
],
|
|
base: [
|
|
"base-base",
|
|
"base-pluginhost",
|
|
"base-build"
|
|
],
|
|
cache: [
|
|
"cache-base",
|
|
"cache-offline",
|
|
"cache-plugin"
|
|
],
|
|
charts: [
|
|
"charts-base"
|
|
],
|
|
collection: [
|
|
"array-extras",
|
|
"arraylist",
|
|
"arraylist-add",
|
|
"arraylist-filter",
|
|
"array-invoke"
|
|
],
|
|
color: [
|
|
"color-base",
|
|
"color-hsl",
|
|
"color-harmony"
|
|
],
|
|
controller: [
|
|
"router"
|
|
],
|
|
dataschema: [
|
|
"dataschema-base",
|
|
"dataschema-json",
|
|
"dataschema-xml",
|
|
"dataschema-array",
|
|
"dataschema-text"
|
|
],
|
|
datasource: [
|
|
"datasource-local",
|
|
"datasource-io",
|
|
"datasource-get",
|
|
"datasource-function",
|
|
"datasource-cache",
|
|
"datasource-jsonschema",
|
|
"datasource-xmlschema",
|
|
"datasource-arrayschema",
|
|
"datasource-textschema",
|
|
"datasource-polling"
|
|
],
|
|
datatable: [
|
|
"datatable-core",
|
|
"datatable-table",
|
|
"datatable-head",
|
|
"datatable-body",
|
|
"datatable-base",
|
|
"datatable-column-widths",
|
|
"datatable-message",
|
|
"datatable-mutable",
|
|
"datatable-sort",
|
|
"datatable-datasource"
|
|
],
|
|
datatype: [
|
|
"datatype-date",
|
|
"datatype-number",
|
|
"datatype-xml"
|
|
],
|
|
"datatype-date": [
|
|
"datatype-date-parse",
|
|
"datatype-date-format",
|
|
"datatype-date-math"
|
|
],
|
|
"datatype-number": [
|
|
"datatype-number-parse",
|
|
"datatype-number-format"
|
|
],
|
|
"datatype-xml": [
|
|
"datatype-xml-parse",
|
|
"datatype-xml-format"
|
|
],
|
|
dd: [
|
|
"dd-ddm-base",
|
|
"dd-ddm",
|
|
"dd-ddm-drop",
|
|
"dd-drag",
|
|
"dd-proxy",
|
|
"dd-constrain",
|
|
"dd-drop",
|
|
"dd-scroll",
|
|
"dd-delegate"
|
|
],
|
|
dom: [
|
|
"dom-base",
|
|
"dom-screen",
|
|
"dom-style",
|
|
"selector-native",
|
|
"selector"
|
|
],
|
|
editor: [
|
|
"frame",
|
|
"editor-selection",
|
|
"exec-command",
|
|
"editor-base",
|
|
"editor-para",
|
|
"editor-br",
|
|
"editor-bidi",
|
|
"editor-tab",
|
|
"createlink-base"
|
|
],
|
|
event: [
|
|
"event-base",
|
|
"event-delegate",
|
|
"event-synthetic",
|
|
"event-mousewheel",
|
|
"event-mouseenter",
|
|
"event-key",
|
|
"event-focus",
|
|
"event-resize",
|
|
"event-hover",
|
|
"event-outside",
|
|
"event-touch",
|
|
"event-move",
|
|
"event-flick",
|
|
"event-valuechange",
|
|
"event-tap"
|
|
],
|
|
"event-custom": [
|
|
"event-custom-base",
|
|
"event-custom-complex"
|
|
],
|
|
"event-gestures": [
|
|
"event-flick",
|
|
"event-move"
|
|
],
|
|
handlebars: [
|
|
"handlebars-compiler"
|
|
],
|
|
highlight: [
|
|
"highlight-base",
|
|
"highlight-accentfold"
|
|
],
|
|
history: [
|
|
"history-base",
|
|
"history-hash",
|
|
"history-hash-ie",
|
|
"history-html5"
|
|
],
|
|
io: [
|
|
"io-base",
|
|
"io-xdr",
|
|
"io-form",
|
|
"io-upload-iframe",
|
|
"io-queue"
|
|
],
|
|
json: [
|
|
"json-parse",
|
|
"json-stringify"
|
|
],
|
|
loader: [
|
|
"loader-base",
|
|
"loader-rollup",
|
|
"loader-yui3"
|
|
],
|
|
node: [
|
|
"node-base",
|
|
"node-event-delegate",
|
|
"node-pluginhost",
|
|
"node-screen",
|
|
"node-style"
|
|
],
|
|
pluginhost: [
|
|
"pluginhost-base",
|
|
"pluginhost-config"
|
|
],
|
|
querystring: [
|
|
"querystring-parse",
|
|
"querystring-stringify"
|
|
],
|
|
recordset: [
|
|
"recordset-base",
|
|
"recordset-sort",
|
|
"recordset-filter",
|
|
"recordset-indexer"
|
|
],
|
|
resize: [
|
|
"resize-base",
|
|
"resize-proxy",
|
|
"resize-constrain"
|
|
],
|
|
slider: [
|
|
"slider-base",
|
|
"slider-value-range",
|
|
"clickable-rail",
|
|
"range-slider"
|
|
],
|
|
template: [
|
|
"template-base",
|
|
"template-micro"
|
|
],
|
|
text: [
|
|
"text-accentfold",
|
|
"text-wordbreak"
|
|
],
|
|
widget: [
|
|
"widget-base",
|
|
"widget-htmlparser",
|
|
"widget-skin",
|
|
"widget-uievents"
|
|
]
|
|
};
|
|
}, '3.12.0', {
|
|
use: [
|
|
"yui-base",
|
|
"get",
|
|
"features",
|
|
"intl-base",
|
|
"yui-log",
|
|
"yui-later",
|
|
"loader-base",
|
|
"loader-rollup",
|
|
"loader-yui3"
|
|
]
|
|
}), YUI.add('get', function(Y, NAME) {
|
|
var CUSTOM_ATTRS, Get, Transaction, Lang = Y.Lang;
|
|
Y.Get = Get = {
|
|
cssOptions: {
|
|
attributes: {
|
|
rel: 'stylesheet'
|
|
},
|
|
doc: Y.config.linkDoc || Y.config.doc,
|
|
pollInterval: 50
|
|
},
|
|
jsOptions: {
|
|
autopurge: !0,
|
|
doc: Y.config.scriptDoc || Y.config.doc
|
|
},
|
|
options: {
|
|
attributes: {
|
|
charset: 'utf-8'
|
|
},
|
|
purgethreshold: 20
|
|
},
|
|
REGEX_CSS: /\.css(?:[?;].*)?$/i,
|
|
REGEX_JS: /\.js(?:[?;].*)?$/i,
|
|
_insertCache: {},
|
|
_pending: null,
|
|
_purgeNodes: [],
|
|
_queue: [],
|
|
abort: function(transaction) {
|
|
var i, id, item, len, pending;
|
|
if (!transaction.abort) {
|
|
if (id = transaction, pending = this._pending, transaction = null, pending && pending.transaction.id === id) transaction = pending.transaction, this._pending = null;
|
|
else for(i = 0, len = this._queue.length; i < len; ++i)if ((item = this._queue[i].transaction).id === id) {
|
|
transaction = item, this._queue.splice(i, 1);
|
|
break;
|
|
}
|
|
}
|
|
transaction && transaction.abort();
|
|
},
|
|
css: function(urls, options, callback) {
|
|
return this._load('css', urls, options, callback);
|
|
},
|
|
js: function(urls, options, callback) {
|
|
return this._load('js', urls, options, callback);
|
|
},
|
|
load: function(urls, options, callback) {
|
|
return this._load(null, urls, options, callback);
|
|
},
|
|
_autoPurge: function(threshold) {
|
|
threshold && this._purgeNodes.length >= threshold && this._purge(this._purgeNodes);
|
|
},
|
|
_getEnv: function() {
|
|
var doc = Y.config.doc, ua = Y.UA;
|
|
return this._env = {
|
|
async: doc && !0 === doc.createElement('script').async || ua.ie >= 10,
|
|
cssFail: ua.gecko >= 9 || ua.compareVersions(ua.webkit, 535.24) >= 0,
|
|
cssLoad: (!ua.gecko && !ua.webkit || ua.gecko >= 9 || ua.compareVersions(ua.webkit, 535.24) >= 0) && !(ua.chrome && ua.chrome <= 18),
|
|
preservesScriptOrder: !!(ua.gecko || ua.opera || ua.ie && ua.ie >= 10)
|
|
};
|
|
},
|
|
_getTransaction: function(urls, options) {
|
|
var i, len, req, url, requests = [];
|
|
for(Lang.isArray(urls) || (urls = [
|
|
urls
|
|
]), (options = Y.merge(this.options, options)).attributes = Y.merge(this.options.attributes, options.attributes), i = 0, len = urls.length; i < len; ++i){
|
|
if (url = urls[i], req = {
|
|
attributes: {}
|
|
}, 'string' == typeof url) req.url = url;
|
|
else {
|
|
if (!url.url) continue;
|
|
Y.mix(req, url, !1, null, 0, !0), url = url.url;
|
|
}
|
|
Y.mix(req, options, !1, null, 0, !0), req.type || (this.REGEX_CSS.test(url) ? req.type = 'css' : (this.REGEX_JS.test(url), req.type = 'js')), Y.mix(req, 'js' === req.type ? this.jsOptions : this.cssOptions, !1, null, 0, !0), req.attributes.id || (req.attributes.id = Y.guid()), req.win ? req.doc = req.win.document : req.win = req.doc.defaultView || req.doc.parentWindow, req.charset && (req.attributes.charset = req.charset), requests.push(req);
|
|
}
|
|
return new Transaction(requests, options);
|
|
},
|
|
_load: function(type, urls, options, callback) {
|
|
var transaction;
|
|
return 'function' == typeof options && (callback = options, options = {}), options || (options = {}), options.type = type, options._onFinish = Get._onTransactionFinish, this._env || this._getEnv(), transaction = this._getTransaction(urls, options), this._queue.push({
|
|
callback: callback,
|
|
transaction: transaction
|
|
}), this._next(), transaction;
|
|
},
|
|
_onTransactionFinish: function() {
|
|
Get._pending = null, Get._next();
|
|
},
|
|
_next: function() {
|
|
var item;
|
|
!this._pending && (item = this._queue.shift()) && (this._pending = item, item.transaction.execute(item.callback));
|
|
},
|
|
_purge: function(nodes) {
|
|
for(var index, node, purgeNodes = this._purgeNodes, isTransaction = nodes !== purgeNodes; node = nodes.pop();)node._yuiget_finished && (node.parentNode && node.parentNode.removeChild(node), isTransaction && (index = Y.Array.indexOf(purgeNodes, node)) > -1 && purgeNodes.splice(index, 1));
|
|
}
|
|
}, Get.script = Get.js, Get.Transaction = Transaction = function(requests, options) {
|
|
var self = this;
|
|
self.id = Transaction._lastId += 1, self.data = options.data, self.errors = [], self.nodes = [], self.options = options, self.requests = requests, self._callbacks = [], self._queue = [], self._reqsWaiting = 0, self.tId = self.id, self.win = options.win || Y.config.win;
|
|
}, Transaction._lastId = 0, Transaction.prototype = {
|
|
_state: 'new',
|
|
abort: function(msg) {
|
|
this._pending = null, this._pendingCSS = null, this._pollTimer = clearTimeout(this._pollTimer), this._queue = [], this._reqsWaiting = 0, this.errors.push({
|
|
error: msg || 'Aborted'
|
|
}), this._finish();
|
|
},
|
|
execute: function(callback) {
|
|
var i, len, queue, req, self = this, requests = self.requests, state = self._state;
|
|
if ('done' === state) {
|
|
callback && callback(self.errors.length ? self.errors : null, self);
|
|
return;
|
|
}
|
|
if (callback && self._callbacks.push(callback), 'executing' !== state) {
|
|
for(self._state = 'executing', self._queue = queue = [], self.options.timeout && (self._timeout = setTimeout(function() {
|
|
self.abort('Timeout');
|
|
}, self.options.timeout)), self._reqsWaiting = requests.length, i = 0, len = requests.length; i < len; ++i)(req = requests[i]).async || 'css' === req.type ? self._insert(req) : queue.push(req);
|
|
self._next();
|
|
}
|
|
},
|
|
purge: function() {
|
|
Get._purge(this.nodes);
|
|
},
|
|
_createNode: function(name, attrs, doc) {
|
|
var attr, testEl, node = doc.createElement(name);
|
|
for(attr in CUSTOM_ATTRS || ((testEl = doc.createElement('div')).setAttribute('class', 'a'), CUSTOM_ATTRS = 'a' === testEl.className ? {} : {
|
|
'for': 'htmlFor',
|
|
'class': 'className'
|
|
}), attrs)attrs.hasOwnProperty(attr) && node.setAttribute(CUSTOM_ATTRS[attr] || attr, attrs[attr]);
|
|
return node;
|
|
},
|
|
_finish: function() {
|
|
var data, i, len, errors = this.errors.length ? this.errors : null, options = this.options, thisObj = options.context || this;
|
|
if ('done' !== this._state) {
|
|
for(i = 0, this._state = 'done', len = this._callbacks.length; i < len; ++i)this._callbacks[i].call(thisObj, errors, this);
|
|
data = this._getEventData(), errors ? (options.onTimeout && 'Timeout' === errors[errors.length - 1].error && options.onTimeout.call(thisObj, data), options.onFailure && options.onFailure.call(thisObj, data)) : options.onSuccess && options.onSuccess.call(thisObj, data), options.onEnd && options.onEnd.call(thisObj, data), options._onFinish && options._onFinish();
|
|
}
|
|
},
|
|
_getEventData: function(req) {
|
|
return req ? Y.merge(this, {
|
|
abort: this.abort,
|
|
purge: this.purge,
|
|
request: req,
|
|
url: req.url,
|
|
win: req.win
|
|
}) : this;
|
|
},
|
|
_getInsertBefore: function(req) {
|
|
var cache, docStamp, doc = req.doc, el = req.insertBefore;
|
|
return el ? 'string' == typeof el ? doc.getElementById(el) : el : (el = (cache = Get._insertCache)[docStamp = Y.stamp(doc)]) ? el : (el = doc.getElementsByTagName('base')[0]) ? cache[docStamp] = el : (el = doc.head || doc.getElementsByTagName('head')[0]) ? (el.appendChild(doc.createTextNode('')), cache[docStamp] = el.lastChild) : cache[docStamp] = doc.getElementsByTagName('script')[0];
|
|
},
|
|
_insert: function(req) {
|
|
var cssTimeout, nodeType, env = Get._env, insertBefore = this._getInsertBefore(req), isScript = 'js' === req.type, node = req.node, self = this, ua = Y.UA;
|
|
function onError() {
|
|
self._progress('Failed to load ' + req.url, req);
|
|
}
|
|
function onLoad() {
|
|
cssTimeout && clearTimeout(cssTimeout), self._progress(null, req);
|
|
}
|
|
node || (nodeType = isScript ? 'script' : !env.cssLoad && ua.gecko ? 'style' : 'link', node = req.node = this._createNode(nodeType, req.attributes, req.doc)), isScript ? (node.setAttribute('src', req.url), req.async ? node.async = !0 : (env.async && (node.async = !1), env.preservesScriptOrder || (this._pending = req))) : !env.cssLoad && ua.gecko ? node.innerHTML = (req.attributes.charset ? '@charset "' + req.attributes.charset + '";' : '') + '@import "' + req.url + '";' : node.setAttribute('href', req.url), isScript && ua.ie && (ua.ie < 9 || document.documentMode && document.documentMode < 9) ? node.onreadystatechange = function() {
|
|
/loaded|complete/.test(node.readyState) && (node.onreadystatechange = null, onLoad());
|
|
} : isScript || env.cssLoad ? (ua.ie >= 10 ? (node.onerror = function() {
|
|
setTimeout(onError, 0);
|
|
}, node.onload = function() {
|
|
setTimeout(onLoad, 0);
|
|
}) : (node.onerror = onError, node.onload = onLoad), env.cssFail || isScript || (cssTimeout = setTimeout(onError, req.timeout || 3000))) : this._poll(req), this.nodes.push(node), insertBefore.parentNode.insertBefore(node, insertBefore);
|
|
},
|
|
_next: function() {
|
|
!this._pending && (this._queue.length ? this._insert(this._queue.shift()) : this._reqsWaiting || this._finish());
|
|
},
|
|
_poll: function(newReq) {
|
|
var i, j, nodeHref, req, sheets, self = this, pendingCSS = self._pendingCSS, isWebKit = Y.UA.webkit;
|
|
if (!newReq || (pendingCSS || (pendingCSS = self._pendingCSS = []), pendingCSS.push(newReq), !self._pollTimer)) {
|
|
for(i = 0, self._pollTimer = null; i < pendingCSS.length; ++i)if (req = pendingCSS[i], isWebKit) {
|
|
for(j = (sheets = req.doc.styleSheets).length, nodeHref = req.node.href; --j >= 0;)if (sheets[j].href === nodeHref) {
|
|
pendingCSS.splice(i, 1), i -= 1, self._progress(null, req);
|
|
break;
|
|
}
|
|
} else try {
|
|
req.node.sheet.cssRules, pendingCSS.splice(i, 1), i -= 1, self._progress(null, req);
|
|
} catch (ex) {}
|
|
pendingCSS.length && (self._pollTimer = setTimeout(function() {
|
|
self._poll.call(self);
|
|
}, self.options.pollInterval));
|
|
}
|
|
},
|
|
_progress: function(err, req) {
|
|
var options = this.options;
|
|
err && (req.error = err, this.errors.push({
|
|
error: err,
|
|
request: req
|
|
})), req.node._yuiget_finished = req.finished = !0, options.onProgress && options.onProgress.call(options.context || this, this._getEventData(req)), req.autopurge && (Get._autoPurge(this.options.purgethreshold), Get._purgeNodes.push(req.node)), this._pending === req && (this._pending = null), this._reqsWaiting -= 1, this._next();
|
|
}
|
|
};
|
|
}, '3.12.0', {
|
|
requires: [
|
|
"yui-base"
|
|
]
|
|
}), YUI.add('features', function(Y2, NAME) {
|
|
var feature_tests = {};
|
|
Y2.mix(Y2.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], result = [];
|
|
return cat_o && Y2.Object.each(cat_o, function(v, k) {
|
|
result.push(k + ':' + (Y2.Features.test(cat, k, args) ? 1 : 0));
|
|
}), result.length ? result.join(';') : '';
|
|
},
|
|
test: function(cat, name, args) {
|
|
args = args || [];
|
|
var result, ua, test, cat_o = feature_tests[cat], feature = cat_o && cat_o[name];
|
|
return feature && (result = feature.result, Y2.Lang.isUndefined(result) && ((ua = feature.ua) && (result = Y2.UA[ua]), (test = feature.test) && (!ua || result) && (result = test.apply(Y2, args)), feature.result = result)), result;
|
|
}
|
|
});
|
|
var add = Y2.Features.add;
|
|
add('load', '0', {
|
|
name: "app-transitions-native",
|
|
test: function(Y) {
|
|
var doc = Y.config.doc, node = doc ? doc.documentElement : null;
|
|
return !!node && !!node.style && ('MozTransition' in node.style || 'WebkitTransition' in node.style || 'transition' in node.style);
|
|
},
|
|
trigger: "app-transitions"
|
|
}), add('load', '1', {
|
|
name: "autocomplete-list-keys",
|
|
test: function(Y) {
|
|
return !(Y.UA.ios || Y.UA.android);
|
|
},
|
|
trigger: "autocomplete-list"
|
|
}), add('load', '2', {
|
|
name: "dd-gestures",
|
|
trigger: "dd-drag",
|
|
ua: "touchEnabled"
|
|
}), add('load', '3', {
|
|
name: "dom-style-ie",
|
|
test: function(Y) {
|
|
var testFeature = Y.Features.test, addFeature = Y.Features.add, WINDOW = Y.config.win, DOCUMENT = Y.config.doc;
|
|
return addFeature('style', 'computedStyle', {
|
|
test: function() {
|
|
return WINDOW && 'getComputedStyle' in WINDOW;
|
|
}
|
|
}), addFeature('style', 'opacity', {
|
|
test: function() {
|
|
return DOCUMENT && 'opacity' in DOCUMENT.documentElement.style;
|
|
}
|
|
}), !testFeature('style', 'opacity') && !testFeature('style', 'computedStyle');
|
|
},
|
|
trigger: "dom-style"
|
|
}), add('load', '4', {
|
|
name: "editor-para-ie",
|
|
trigger: "editor-para",
|
|
ua: "ie",
|
|
when: "instead"
|
|
}), add('load', '5', {
|
|
name: "event-base-ie",
|
|
test: function(Y) {
|
|
var imp = Y.config.doc && Y.config.doc.implementation;
|
|
return imp && !imp.hasFeature('Events', '2.0');
|
|
},
|
|
trigger: "node-base"
|
|
}), add('load', '6', {
|
|
name: "graphics-canvas",
|
|
test: function(Y) {
|
|
var DOCUMENT = Y.config.doc, useCanvas = Y.config.defaultGraphicEngine && "canvas" == Y.config.defaultGraphicEngine, canvas = DOCUMENT && DOCUMENT.createElement("canvas");
|
|
return (!(DOCUMENT && DOCUMENT.implementation.hasFeature("http://www.w3.org/TR/SVG11/feature#BasicStructure", "1.1")) || useCanvas) && canvas && canvas.getContext && canvas.getContext("2d");
|
|
},
|
|
trigger: "graphics"
|
|
}), add('load', '7', {
|
|
name: "graphics-canvas-default",
|
|
test: function(Y) {
|
|
var DOCUMENT = Y.config.doc, useCanvas = Y.config.defaultGraphicEngine && "canvas" == Y.config.defaultGraphicEngine, canvas = DOCUMENT && DOCUMENT.createElement("canvas");
|
|
return (!(DOCUMENT && DOCUMENT.implementation.hasFeature("http://www.w3.org/TR/SVG11/feature#BasicStructure", "1.1")) || useCanvas) && canvas && canvas.getContext && canvas.getContext("2d");
|
|
},
|
|
trigger: "graphics"
|
|
}), add('load', '8', {
|
|
name: "graphics-svg",
|
|
test: function(Y) {
|
|
var DOCUMENT = Y.config.doc, useSVG = !Y.config.defaultGraphicEngine || "canvas" != Y.config.defaultGraphicEngine, canvas = DOCUMENT && DOCUMENT.createElement("canvas"), svg = DOCUMENT && DOCUMENT.implementation.hasFeature("http://www.w3.org/TR/SVG11/feature#BasicStructure", "1.1");
|
|
return svg && (useSVG || !canvas);
|
|
},
|
|
trigger: "graphics"
|
|
}), add('load', '9', {
|
|
name: "graphics-svg-default",
|
|
test: function(Y) {
|
|
var DOCUMENT = Y.config.doc, useSVG = !Y.config.defaultGraphicEngine || "canvas" != Y.config.defaultGraphicEngine, canvas = DOCUMENT && DOCUMENT.createElement("canvas"), svg = DOCUMENT && DOCUMENT.implementation.hasFeature("http://www.w3.org/TR/SVG11/feature#BasicStructure", "1.1");
|
|
return svg && (useSVG || !canvas);
|
|
},
|
|
trigger: "graphics"
|
|
}), add('load', '10', {
|
|
name: "graphics-vml",
|
|
test: function(Y) {
|
|
var DOCUMENT = Y.config.doc, canvas = DOCUMENT && DOCUMENT.createElement("canvas");
|
|
return DOCUMENT && !DOCUMENT.implementation.hasFeature("http://www.w3.org/TR/SVG11/feature#BasicStructure", "1.1") && (!canvas || !canvas.getContext || !canvas.getContext("2d"));
|
|
},
|
|
trigger: "graphics"
|
|
}), add('load', '11', {
|
|
name: "graphics-vml-default",
|
|
test: function(Y) {
|
|
var DOCUMENT = Y.config.doc, canvas = DOCUMENT && DOCUMENT.createElement("canvas");
|
|
return DOCUMENT && !DOCUMENT.implementation.hasFeature("http://www.w3.org/TR/SVG11/feature#BasicStructure", "1.1") && (!canvas || !canvas.getContext || !canvas.getContext("2d"));
|
|
},
|
|
trigger: "graphics"
|
|
}), add('load', '12', {
|
|
name: "history-hash-ie",
|
|
test: function(Y) {
|
|
var docMode = Y.config.doc && Y.config.doc.documentMode;
|
|
return Y.UA.ie && (!('onhashchange' in Y.config.win) || !docMode || docMode < 8);
|
|
},
|
|
trigger: "history-hash"
|
|
}), add('load', '13', {
|
|
name: "io-nodejs",
|
|
trigger: "io-base",
|
|
ua: "nodejs"
|
|
}), add('load', '14', {
|
|
name: "json-parse-shim",
|
|
test: function(Y) {
|
|
var _JSON = Y.config.global.JSON, Native = '[object JSON]' === Object.prototype.toString.call(_JSON) && _JSON, nativeSupport = !1 !== Y.config.useNativeJSONParse && !!Native;
|
|
if (nativeSupport) try {
|
|
nativeSupport = Native.parse('{"ok":false}', function(k, v) {
|
|
return "ok" === k || v;
|
|
}).ok;
|
|
} catch (e) {
|
|
nativeSupport = !1;
|
|
}
|
|
return !nativeSupport;
|
|
},
|
|
trigger: "json-parse"
|
|
}), add('load', '15', {
|
|
name: "json-stringify-shim",
|
|
test: function(Y) {
|
|
var _JSON = Y.config.global.JSON, Native = '[object JSON]' === Object.prototype.toString.call(_JSON) && _JSON, nativeSupport = !1 !== Y.config.useNativeJSONStringify && !!Native;
|
|
if (nativeSupport) try {
|
|
nativeSupport = '0' === Native.stringify(0);
|
|
} catch (e) {
|
|
nativeSupport = !1;
|
|
}
|
|
return !nativeSupport;
|
|
},
|
|
trigger: "json-stringify"
|
|
}), add('load', '16', {
|
|
name: "scrollview-base-ie",
|
|
trigger: "scrollview-base",
|
|
ua: "ie"
|
|
}), add('load', '17', {
|
|
name: "selector-css2",
|
|
test: function(Y) {
|
|
var DOCUMENT = Y.config.doc;
|
|
return DOCUMENT && !('querySelectorAll' in DOCUMENT);
|
|
},
|
|
trigger: "selector"
|
|
}), add('load', '18', {
|
|
name: "transition-timer",
|
|
test: function(Y) {
|
|
var DOCUMENT = Y.config.doc, node = DOCUMENT ? DOCUMENT.documentElement : null, ret = !0;
|
|
return node && node.style && (ret = !('MozTransition' in node.style || 'WebkitTransition' in node.style || 'transition' in node.style)), ret;
|
|
},
|
|
trigger: "transition"
|
|
}), add('load', '19', {
|
|
name: "widget-base-ie",
|
|
trigger: "widget-base",
|
|
ua: "ie"
|
|
}), add('load', '20', {
|
|
name: "yql-jsonp",
|
|
test: function(Y) {
|
|
return !Y.UA.nodejs && !Y.UA.winjs;
|
|
},
|
|
trigger: "yql",
|
|
when: "after"
|
|
}), add('load', '21', {
|
|
name: "yql-nodejs",
|
|
trigger: "yql",
|
|
ua: "nodejs",
|
|
when: "after"
|
|
}), add('load', '22', {
|
|
name: "yql-winjs",
|
|
trigger: "yql",
|
|
ua: "winjs",
|
|
when: "after"
|
|
});
|
|
}, '3.12.0', {
|
|
requires: [
|
|
"yui-base"
|
|
]
|
|
}), YUI.add('intl-base', function(Y, NAME) {
|
|
var SPLIT_REGEX = /[, ]/;
|
|
Y.mix(Y.namespace('Intl'), {
|
|
lookupBestLang: function(preferredLanguages, availableLanguages) {
|
|
var i2, language1, result, index;
|
|
function scan(language) {
|
|
var i;
|
|
for(i = 0; i < availableLanguages.length; i += 1)if (language.toLowerCase() === availableLanguages[i].toLowerCase()) return availableLanguages[i];
|
|
}
|
|
for(Y.Lang.isString(preferredLanguages) && (preferredLanguages = preferredLanguages.split(SPLIT_REGEX)), i2 = 0; i2 < preferredLanguages.length; i2 += 1)if ((language1 = preferredLanguages[i2]) && '*' !== language1) for(; language1.length > 0;){
|
|
if (result = scan(language1)) return result;
|
|
if ((index = language1.lastIndexOf('-')) >= 0) language1 = language1.substring(0, index), index >= 2 && '-' === language1.charAt(index - 2) && (language1 = language1.substring(0, index - 2));
|
|
else break;
|
|
}
|
|
return '';
|
|
}
|
|
});
|
|
}, '3.12.0', {
|
|
requires: [
|
|
"yui-base"
|
|
]
|
|
}), YUI.add('yui-log', function(Y3, NAME) {
|
|
var INSTANCE = Y3, LOGEVENT = 'yui:log', UNDEFINED = 'undefined', LEVELS = {
|
|
debug: 1,
|
|
info: 2,
|
|
warn: 4,
|
|
error: 8
|
|
};
|
|
INSTANCE.log = function(msg, cat, src, silent) {
|
|
var bail, excl, incl, m, f, minlevel, Y = INSTANCE, c = Y.config, publisher = Y.fire ? Y : YUI.Env.globalEvents;
|
|
return c.debug && (void 0 !== (src = src || "") && (excl = c.logExclude, incl = c.logInclude, !incl || src in incl ? incl && src in incl ? bail = !incl[src] : excl && src in excl && (bail = excl[src]) : bail = 1, Y.config.logLevel = Y.config.logLevel || 'debug', minlevel = LEVELS[Y.config.logLevel.toLowerCase()], cat in LEVELS && LEVELS[cat] < minlevel && (bail = 1)), bail || (c.useBrowserConsole && (m = src ? src + ': ' + msg : msg, Y.Lang.isFunction(c.logFn) ? c.logFn.call(Y, msg, cat, src) : typeof console !== UNDEFINED && console.log ? (f = cat && console[cat] && cat in LEVELS ? cat : 'log', console[f](m)) : typeof opera !== UNDEFINED && opera.postError(m)), publisher && !silent && (publisher !== Y || publisher.getEvent(LOGEVENT) || publisher.publish(LOGEVENT, {
|
|
broadcast: 2
|
|
}), publisher.fire(LOGEVENT, {
|
|
msg: msg,
|
|
cat: cat,
|
|
src: src
|
|
})))), Y;
|
|
}, INSTANCE.message = function() {
|
|
return INSTANCE.log.apply(INSTANCE, arguments);
|
|
};
|
|
}, '3.12.0', {
|
|
requires: [
|
|
"yui-base"
|
|
]
|
|
}), YUI.add('yui-later', function(Y, NAME) {
|
|
var NO_ARGS = [];
|
|
Y.later = function(when, o, fn, data, periodic) {
|
|
when = when || 0, data = Y.Lang.isUndefined(data) ? NO_ARGS : Y.Array(data);
|
|
var cancelled = !1, method = (o = o || Y.config.win || Y) && Y.Lang.isString(fn) ? o[fn] : fn, wrapper = function() {
|
|
cancelled || (method.apply ? method.apply(o, data || NO_ARGS) : method(data[0], data[1], data[2], data[3]));
|
|
}, id = periodic ? setInterval(wrapper, when) : setTimeout(wrapper, when);
|
|
return {
|
|
id: id,
|
|
interval: periodic,
|
|
cancel: function() {
|
|
cancelled = !0, this.interval ? clearInterval(id) : clearTimeout(id);
|
|
}
|
|
};
|
|
}, Y.Lang.later = Y.later;
|
|
}, '3.12.0', {
|
|
requires: [
|
|
"yui-base"
|
|
]
|
|
}), YUI.add('loader-base', function(Y, NAME) {
|
|
VERSION = Y.version, BUILD = '/build/', COMBO_BASE = (CDN_BASE = Y.Env.base) + 'combo?', META = {
|
|
version: VERSION,
|
|
root: VERSION + '/',
|
|
base: Y.Env.base,
|
|
comboBase: COMBO_BASE,
|
|
skin: {
|
|
defaultSkin: 'sam',
|
|
base: 'assets/skins/',
|
|
path: 'skin.css',
|
|
after: [
|
|
'cssreset',
|
|
'cssfonts',
|
|
'cssgrids',
|
|
'cssbase',
|
|
'cssreset-context',
|
|
'cssfonts-context'
|
|
]
|
|
},
|
|
groups: {},
|
|
patterns: {}
|
|
}, groups = META.groups, yui2Update = function(tnt, yui2, config) {
|
|
var root = "2in3." + (tnt || '4') + '/' + (yui2 || '2.9.0') + BUILD, base = config && config.base ? config.base : CDN_BASE, combo = config && config.comboBase ? config.comboBase : COMBO_BASE;
|
|
groups.yui2.base = base + root, groups.yui2.root = root, groups.yui2.comboBase = combo;
|
|
}, galleryUpdate = function(tag, config) {
|
|
var root = (tag || 'gallery-2013.08.22-21-03') + BUILD, base = config && config.base ? config.base : CDN_BASE, combo = config && config.comboBase ? config.comboBase : COMBO_BASE;
|
|
groups.gallery.base = base + root, groups.gallery.root = root, groups.gallery.comboBase = combo;
|
|
}, groups[VERSION] = {}, groups.gallery = {
|
|
ext: !1,
|
|
combine: !0,
|
|
comboBase: COMBO_BASE,
|
|
update: galleryUpdate,
|
|
patterns: {
|
|
'gallery-': {},
|
|
'lang/gallery-': {},
|
|
'gallerycss-': {
|
|
type: 'css'
|
|
}
|
|
}
|
|
}, groups.yui2 = {
|
|
combine: !0,
|
|
ext: !1,
|
|
comboBase: COMBO_BASE,
|
|
update: yui2Update,
|
|
patterns: {
|
|
'yui2-': {
|
|
configFn: function(me) {
|
|
/-skin|reset|fonts|grids|base/.test(me.name) && (me.type = 'css', me.path = me.path.replace(/\.js/, '.css'), me.path = me.path.replace(/\/yui2-skin/, '/assets/skins/sam/yui2-skin'));
|
|
}
|
|
}
|
|
}
|
|
}, galleryUpdate(), yui2Update(), YUI.Env[VERSION] && Y.mix(META, YUI.Env[VERSION], !1, [
|
|
'modules',
|
|
'groups',
|
|
'skin'
|
|
], 0, !0), YUI.Env[VERSION] = META;
|
|
var VERSION, BUILD, CDN_BASE, COMBO_BASE, META, groups, yui2Update, galleryUpdate, modulekey, NOT_FOUND = {}, NO_REQUIREMENTS = [], GLOBAL_ENV = YUI.Env, GLOBAL_LOADED = GLOBAL_ENV._loaded, INTL = 'intl', VERSION1 = Y.version, YObject = Y.Object, oeach = YObject.each, yArray = Y.Array, _queue = GLOBAL_ENV._loaderQueue, META1 = GLOBAL_ENV[VERSION1], L = Y.Lang, ON_PAGE = GLOBAL_ENV.mods, _path = function(dir, file, type, nomin) {
|
|
var path = dir + '/' + file;
|
|
return nomin || (path += '-min'), path += '.' + (type || 'css');
|
|
};
|
|
YUI.Env._cssLoaded || (YUI.Env._cssLoaded = {}), Y.Env.meta = META1, Y.Loader = function(o) {
|
|
var self = this;
|
|
o = o || {}, modulekey = META1.md5, self.context = Y, self.base = Y.Env.meta.base + Y.Env.meta.root, self.comboBase = Y.Env.meta.comboBase, self.combine = o.base && o.base.indexOf(self.comboBase.substr(0, 20)) > -1, self.comboSep = '&', self.maxURLLength = 1024, self.ignoreRegistered = o.ignoreRegistered, self.root = Y.Env.meta.root, self.timeout = 0, self.forceMap = {}, self.allowRollup = !1, self.filters = {}, self.required = {}, self.patterns = {}, self.moduleInfo = {}, self.groups = Y.merge(Y.Env.meta.groups), self.skin = Y.merge(Y.Env.meta.skin), self.conditions = {}, self.config = o, self._internal = !0, self._populateCache(), self.loaded = GLOBAL_LOADED[VERSION1], self.async = !0, self._inspectPage(), self._internal = !1, self._config(o), self.forceMap = self.force ? Y.Array.hash(self.force) : {}, self.testresults = null, Y.config.tests && (self.testresults = Y.config.tests), self.sorted = [], self.dirty = !0, self.inserted = {}, self.skipped = {}, self.tested = {}, self.ignoreRegistered && self._resetModules();
|
|
}, Y.Loader.prototype = {
|
|
_populateCache: function() {
|
|
var i, self = this, defaults = META1.modules, cache = GLOBAL_ENV._renderedMods;
|
|
if (cache && !self.ignoreRegistered) {
|
|
for(i in cache)cache.hasOwnProperty(i) && (self.moduleInfo[i] = Y.merge(cache[i]));
|
|
for(i in cache = GLOBAL_ENV._conditions)cache.hasOwnProperty(i) && (self.conditions[i] = Y.merge(cache[i]));
|
|
} else for(i in defaults)defaults.hasOwnProperty(i) && self.addModule(defaults[i], i);
|
|
},
|
|
_resetModules: function() {
|
|
var i, o, mod, name, details, self = this;
|
|
for(i in self.moduleInfo)if (self.moduleInfo.hasOwnProperty(i)) {
|
|
if (name = (mod = self.moduleInfo[i]).name, (details = YUI.Env.mods[name] ? YUI.Env.mods[name].details : null) && (self.moduleInfo[name]._reset = !0, self.moduleInfo[name].requires = details.requires || [], self.moduleInfo[name].optional = details.optional || [], self.moduleInfo[name].supersedes = details.supercedes || []), mod.defaults) for(o in mod.defaults)mod.defaults.hasOwnProperty(o) && mod[o] && (mod[o] = mod.defaults[o]);
|
|
delete mod.langCache, delete mod.skinCache, mod.skinnable && self._addSkin(self.skin.defaultSkin, mod.name);
|
|
}
|
|
},
|
|
REGEX_CSS: /\.css(?:[?;].*)?$/i,
|
|
FILTER_DEFS: {
|
|
RAW: {
|
|
searchExp: '-min\\.js',
|
|
replaceStr: '.js'
|
|
},
|
|
DEBUG: {
|
|
searchExp: '-min\\.js',
|
|
replaceStr: '-debug.js'
|
|
},
|
|
COVERAGE: {
|
|
searchExp: '-min\\.js',
|
|
replaceStr: '-coverage.js'
|
|
}
|
|
},
|
|
_inspectPage: function() {
|
|
var v, m, req, mr, i, self = this;
|
|
for(i in self.moduleInfo)self.moduleInfo.hasOwnProperty(i) && (v = self.moduleInfo[i]).type && 'css' === v.type && self.isCSSLoaded(v.name) && (self.loaded[i] = !0);
|
|
for(i in ON_PAGE)ON_PAGE.hasOwnProperty(i) && (v = ON_PAGE[i]).details && (m = self.moduleInfo[v.name], req = v.details.requires, mr = m && m.requires, m ? !m._inspected && req && mr.length !== req.length && delete m.expanded : m = self.addModule(v.details, i), m._inspected = !0);
|
|
},
|
|
_requires: function(mod1, mod2) {
|
|
var i, rm, after_map, s, info = this.moduleInfo, m = info[mod1], other = info[mod2];
|
|
if (!m || !other) return !1;
|
|
if (rm = m.expanded_map, after_map = m.after_map, after_map && mod2 in after_map) return !0;
|
|
if ((after_map = other.after_map) && mod1 in after_map) return !1;
|
|
if (s = info[mod2] && info[mod2].supersedes) {
|
|
for(i = 0; i < s.length; i++)if (this._requires(mod1, s[i])) return !0;
|
|
}
|
|
if (s = info[mod1] && info[mod1].supersedes) {
|
|
for(i = 0; i < s.length; i++)if (this._requires(mod2, s[i])) return !1;
|
|
}
|
|
return !!rm && mod2 in rm || !!m.ext && 'css' === m.type && !other.ext && 'css' === other.type;
|
|
},
|
|
_config: function(o) {
|
|
var i, j, val, a, f, group, groupName, mod3, self = this, mods = [];
|
|
if (o) {
|
|
for(i in o)if (o.hasOwnProperty(i)) {
|
|
if (val = o[i], 'require' === i) self.require(val);
|
|
else if ('skin' === i) 'string' == typeof val && (self.skin.defaultSkin = o.skin, val = {
|
|
defaultSkin: val
|
|
}), Y.mix(self.skin, val, !0);
|
|
else if ('groups' === i) {
|
|
for(j in val)if (val.hasOwnProperty(j) && (groupName = j, group = val[j], self.addGroup(group, groupName), group.aliases)) for(a in group.aliases)group.aliases.hasOwnProperty(a) && self.addAlias(group.aliases[a], a);
|
|
} else if ('modules' === i) for(j in val)val.hasOwnProperty(j) && self.addModule(val[j], j);
|
|
else if ('aliases' === i) for(j in val)val.hasOwnProperty(j) && self.addAlias(val[j], j);
|
|
else 'gallery' === i ? this.groups.gallery.update && this.groups.gallery.update(val, o) : 'yui2' === i || '2in3' === i ? this.groups.yui2.update && this.groups.yui2.update(o['2in3'], o.yui2, o) : self[i] = val;
|
|
}
|
|
}
|
|
if (f = self.filter, L.isString(f) && (f = f.toUpperCase(), self.filterName = f, self.filter = self.FILTER_DEFS[f], 'DEBUG' === f && self.require('yui-log', 'dump')), self.filterName && self.coverage && 'COVERAGE' === self.filterName && L.isArray(self.coverage) && self.coverage.length) {
|
|
for(i = 0; i < self.coverage.length; i++)mod3 = self.coverage[i], self.moduleInfo[mod3] && self.moduleInfo[mod3].use ? mods = [].concat(mods, self.moduleInfo[mod3].use) : mods.push(mod3);
|
|
self.filters = self.filters || {}, Y.Array.each(mods, function(mod) {
|
|
self.filters[mod] = self.FILTER_DEFS.COVERAGE;
|
|
}), self.filterName = 'RAW', self.filter = self.FILTER_DEFS[self.filterName];
|
|
}
|
|
},
|
|
formatSkin: function(skin, mod) {
|
|
var s = 'skin-' + skin;
|
|
return mod && (s = s + '-' + mod), s;
|
|
},
|
|
_addSkin: function(skin, mod, parent) {
|
|
var mdef, pkg, name, nmod, info = this.moduleInfo, sinf = this.skin, ext = info[mod] && info[mod].ext;
|
|
return mod && (info[name = this.formatSkin(skin, mod)] || (pkg = (mdef = info[mod]).pkg || mod, nmod = {
|
|
skin: !0,
|
|
name: name,
|
|
group: mdef.group,
|
|
type: 'css',
|
|
after: sinf.after,
|
|
path: (parent || pkg) + '/' + sinf.base + skin + '/' + mod + '.css',
|
|
ext: ext
|
|
}, mdef.base && (nmod.base = mdef.base), mdef.configFn && (nmod.configFn = mdef.configFn), this.addModule(nmod, name))), name;
|
|
},
|
|
addAlias: function(use, name) {
|
|
YUI.Env.aliases[name] = use, this.addModule({
|
|
name: name,
|
|
use: use
|
|
});
|
|
},
|
|
addGroup: function(o, name) {
|
|
var i, v, mods = o.modules, self = this;
|
|
if (name = name || o.name, o.name = name, self.groups[name] = o, o.patterns) for(i in o.patterns)o.patterns.hasOwnProperty(i) && (o.patterns[i].group = name, self.patterns[i] = o.patterns[i]);
|
|
if (mods) for(i in mods)mods.hasOwnProperty(i) && ('string' == typeof (v = mods[i]) && (v = {
|
|
name: i,
|
|
fullpath: v
|
|
}), v.group = name, self.addModule(v, i));
|
|
},
|
|
addModule: function(o, name) {
|
|
name = name || o.name, 'string' == typeof o && (o = {
|
|
name: name,
|
|
fullpath: o
|
|
});
|
|
var subs, i, l, t, sup, s, smod, plugins, plug, j, langs, packName, supName, flatSup, flatLang, lang, overrides, skinname, when, g, p, trigger, conditions = this.conditions;
|
|
if (this.moduleInfo[name] && this.moduleInfo[name].temp && (o = Y.merge(this.moduleInfo[name], o)), o.name = name, !o || !o.name) return null;
|
|
if (!o.type && (o.type = 'js', (p = o.path || o.fullpath) && this.REGEX_CSS.test(p) && (o.type = 'css')), o.path || o.fullpath || (o.path = _path(name, name, o.type)), o.supersedes = o.supersedes || o.use, o.ext = 'ext' in o ? o.ext : !this._internal, subs = o.submodules, this.moduleInfo[name] = o, o.requires = o.requires || [], this.requires) for(i = 0; i < this.requires.length; i++)o.requires.push(this.requires[i]);
|
|
if (o.group && this.groups && this.groups[o.group] && (g = this.groups[o.group]).requires) for(i = 0; i < g.requires.length; i++)o.requires.push(g.requires[i]);
|
|
if (o.defaults || (o.defaults = {
|
|
requires: o.requires ? [].concat(o.requires) : null,
|
|
supersedes: o.supersedes ? [].concat(o.supersedes) : null,
|
|
optional: o.optional ? [].concat(o.optional) : null
|
|
}), o.skinnable && o.ext && o.temp && (skinname = this._addSkin(this.skin.defaultSkin, name), o.requires.unshift(skinname)), o.requires.length && (o.requires = this.filterRequires(o.requires) || []), !o.langPack && o.lang) for(j = 0, langs = yArray(o.lang); j < langs.length; j++)lang = langs[j], packName = this.getLangPackName(lang, name), (smod = this.moduleInfo[packName]) || (smod = this._addLangPack(lang, o, packName));
|
|
if (subs) {
|
|
for(i in sup = o.supersedes || [], l = 0, subs)if (subs.hasOwnProperty(i)) {
|
|
if ((s = subs[i]).path = s.path || _path(name, i, o.type), s.pkg = name, s.group = o.group, s.supersedes && (sup = sup.concat(s.supersedes)), smod = this.addModule(s, i), sup.push(i), smod.skinnable) {
|
|
if (o.skinnable = !0, (overrides = this.skin.overrides) && overrides[i]) for(j = 0; j < overrides[i].length; j++)skinname = this._addSkin(overrides[i][j], i, name), sup.push(skinname);
|
|
skinname = this._addSkin(this.skin.defaultSkin, i, name), sup.push(skinname);
|
|
}
|
|
if (s.lang && s.lang.length) for(j = 0, langs = yArray(s.lang); j < langs.length; j++)lang = langs[j], packName = this.getLangPackName(lang, name), supName = this.getLangPackName(lang, i), (smod = this.moduleInfo[packName]) || (smod = this._addLangPack(lang, o, packName)), supName in (flatSup = flatSup || yArray.hash(smod.supersedes)) || smod.supersedes.push(supName), o.lang = o.lang || [], lang in (flatLang = flatLang || yArray.hash(o.lang)) || o.lang.push(lang), packName = this.getLangPackName('', name), supName = this.getLangPackName('', i), (smod = this.moduleInfo[packName]) || (smod = this._addLangPack(lang, o, packName)), supName in flatSup || smod.supersedes.push(supName);
|
|
l++;
|
|
}
|
|
o.supersedes = yArray.dedupe(sup), this.allowRollup && (o.rollup = l < 4 ? l : Math.min(l - 1, 4));
|
|
}
|
|
if (plugins = o.plugins) for(i in plugins)plugins.hasOwnProperty(i) && ((plug = plugins[i]).pkg = name, plug.path = plug.path || _path(name, i, o.type), plug.requires = plug.requires || [], plug.group = o.group, this.addModule(plug, i), o.skinnable && this._addSkin(this.skin.defaultSkin, i, name));
|
|
if (o.condition) for(t = o.condition.trigger, YUI.Env.aliases[t] && (t = YUI.Env.aliases[t]), Y.Lang.isArray(t) || (t = [
|
|
t
|
|
]), i = 0; i < t.length; i++)trigger = t[i], when = o.condition.when, conditions[trigger] = conditions[trigger] || {}, conditions[trigger][name] = o.condition, when && 'after' !== when ? 'instead' === when && (o.supersedes = o.supersedes || [], o.supersedes.push(trigger)) : (o.after = o.after || [], o.after.push(trigger));
|
|
return o.supersedes && (o.supersedes = this.filterRequires(o.supersedes)), o.after && (o.after = this.filterRequires(o.after), o.after_map = yArray.hash(o.after)), o.configFn && !1 === o.configFn(o) && (delete this.moduleInfo[name], delete GLOBAL_ENV._renderedMods[name], o = null), o && (GLOBAL_ENV._renderedMods || (GLOBAL_ENV._renderedMods = {}), GLOBAL_ENV._renderedMods[name] = Y.mix(GLOBAL_ENV._renderedMods[name] || {}, o), GLOBAL_ENV._conditions = conditions), o;
|
|
},
|
|
require: function(what) {
|
|
var a = 'string' == typeof what ? yArray(arguments) : what;
|
|
this.dirty = !0, this.required = Y.merge(this.required, yArray.hash(this.filterRequires(a))), this._explodeRollups();
|
|
},
|
|
_explodeRollups: function() {
|
|
var m, m2, i, a, v, len, len2, self = this, r = self.required;
|
|
if (!self.allowRollup) {
|
|
for(i in r)if (r.hasOwnProperty(i) && (m = self.getModule(i)) && m.use) for(a = 0, len = m.use.length; a < len; a++)if ((m2 = self.getModule(m.use[a])) && m2.use) for(v = 0, len2 = m2.use.length; v < len2; v++)r[m2.use[v]] = !0;
|
|
else r[m.use[a]] = !0;
|
|
self.required = r;
|
|
}
|
|
},
|
|
filterRequires: function(r) {
|
|
if (r) {
|
|
Y.Lang.isArray(r) || (r = [
|
|
r
|
|
]), r = Y.Array(r);
|
|
var i, mod, o, m, c = [];
|
|
for(i = 0; i < r.length; i++)if ((mod = this.getModule(r[i])) && mod.use) for(o = 0; o < mod.use.length; o++)(m = this.getModule(mod.use[o])) && m.use && m.name !== mod.name ? c = Y.Array.dedupe([].concat(c, this.filterRequires(m.use))) : c.push(mod.use[o]);
|
|
else c.push(r[i]);
|
|
r = c;
|
|
}
|
|
return r;
|
|
},
|
|
getRequires: function(mod) {
|
|
if (!mod) return NO_REQUIREMENTS;
|
|
if (mod._parsed) return mod.expanded || NO_REQUIREMENTS;
|
|
var i, m, j, add, packName, lang, cond, d, def, r, old_mod, o, skinmod, skindef, skinpar, skinname, hash, reparse, testresults = this.testresults, name = mod.name, adddef = ON_PAGE[name] && ON_PAGE[name].details, intl = mod.lang || mod.intl, info = this.moduleInfo, ftests = Y.Features && Y.Features.tests.load;
|
|
if (mod.temp && adddef && (old_mod = mod, (mod = this.addModule(adddef, name)).group = old_mod.group, mod.pkg = old_mod.pkg, delete mod.expanded), reparse = !((!this.lang || mod.langCache === this.lang) && mod.skinCache === this.skin.defaultSkin), mod.expanded && !reparse) return mod.expanded;
|
|
for(d = [], hash = {}, r = this.filterRequires(mod.requires), mod.lang && (d.unshift('intl'), r.unshift('intl'), intl = !0), o = this.filterRequires(mod.optional), mod._parsed = !0, mod.langCache = this.lang, mod.skinCache = this.skin.defaultSkin, i = 0; i < r.length; i++)if (!hash[r[i]] && (d.push(r[i]), hash[r[i]] = !0, m = this.getModule(r[i]))) for(j = 0, add = this.getRequires(m), intl = intl || m.expanded_map && (INTL in m.expanded_map); j < add.length; j++)d.push(add[j]);
|
|
if (r = this.filterRequires(mod.supersedes)) {
|
|
for(i = 0; i < r.length; i++)if (!hash[r[i]] && (mod.submodules && d.push(r[i]), hash[r[i]] = !0, m = this.getModule(r[i]))) for(j = 0, add = this.getRequires(m), intl = intl || m.expanded_map && (INTL in m.expanded_map); j < add.length; j++)d.push(add[j]);
|
|
}
|
|
if (o && this.loadOptional) {
|
|
for(i = 0; i < o.length; i++)if (!hash[o[i]] && (d.push(o[i]), hash[o[i]] = !0, m = info[o[i]])) for(j = 0, add = this.getRequires(m), intl = intl || m.expanded_map && (INTL in m.expanded_map); j < add.length; j++)d.push(add[j]);
|
|
}
|
|
if (cond = this.conditions[name]) {
|
|
if (mod._parsed = !1, testresults && ftests) oeach(testresults, function(result, id) {
|
|
var condmod = ftests[id].name;
|
|
!hash[condmod] && ftests[id].trigger === name && result && ftests[id] && (hash[condmod] = !0, d.push(condmod));
|
|
});
|
|
else for(i in cond)if (cond.hasOwnProperty(i) && !hash[i] && (def = cond[i]) && (!def.ua && !def.test || def.ua && Y.UA[def.ua] || def.test && def.test(Y, r)) && (hash[i] = !0, d.push(i), m = this.getModule(i))) for(j = 0, add = this.getRequires(m); j < add.length; j++)d.push(add[j]);
|
|
}
|
|
if (mod.skinnable) {
|
|
for(i in skindef = this.skin.overrides, YUI.Env.aliases)YUI.Env.aliases.hasOwnProperty(i) && Y.Array.indexOf(YUI.Env.aliases[i], name) > -1 && (skinpar = i);
|
|
if (skindef && (skindef[name] || skinpar && skindef[skinpar])) for(skinname = name, skindef[skinpar] && (skinname = skinpar), i = 0; i < skindef[skinname].length; i++)skinmod = this._addSkin(skindef[skinname][i], name), this.isCSSLoaded(skinmod, this._boot) || d.push(skinmod);
|
|
else skinmod = this._addSkin(this.skin.defaultSkin, name), this.isCSSLoaded(skinmod, this._boot) || d.push(skinmod);
|
|
}
|
|
return mod._parsed = !1, intl && (mod.lang && !mod.langPack && Y.Intl && (lang = Y.Intl.lookupBestLang(this.lang || '', mod.lang), (packName = this.getLangPackName(lang, name)) && d.unshift(packName)), d.unshift(INTL)), mod.expanded_map = yArray.hash(d), mod.expanded = YObject.keys(mod.expanded_map), mod.expanded;
|
|
},
|
|
isCSSLoaded: function(name, skip) {
|
|
if (!name || !YUI.Env.cssStampEl || !skip && this.ignoreRegistered) return !1;
|
|
var el = YUI.Env.cssStampEl, ret = !1, mod = YUI.Env._cssLoaded[name], style = el.currentStyle;
|
|
return void 0 !== mod ? mod : (el.className = name, style || (style = Y.config.doc.defaultView.getComputedStyle(el, null)), style && 'none' === style.display && (ret = !0), el.className = '', YUI.Env._cssLoaded[name] = ret, ret);
|
|
},
|
|
getProvides: function(name) {
|
|
var o, s, m = this.getModule(name);
|
|
return m ? (m && !m.provides && (o = {}, (s = m.supersedes) && yArray.each(s, function(v) {
|
|
Y.mix(o, this.getProvides(v));
|
|
}, this), o[name] = !0, m.provides = o), m.provides) : NOT_FOUND;
|
|
},
|
|
calculate: function(o, type) {
|
|
(o || type || this.dirty) && (o && this._config(o), this._init || this._setup(), this._explode(), this.allowRollup ? this._rollup() : this._explodeRollups(), this._reduce(), this._sort());
|
|
},
|
|
_addLangPack: function(lang, m, packName) {
|
|
var conf, name = m.name;
|
|
return !this.moduleInfo[packName] && (conf = {
|
|
path: _path(m.pkg || name, packName, 'js', !0),
|
|
intl: !0,
|
|
langPack: !0,
|
|
ext: m.ext,
|
|
group: m.group,
|
|
supersedes: []
|
|
}, m.root && (conf.root = m.root), m.base && (conf.base = m.base), m.configFn && (conf.configFn = m.configFn), this.addModule(conf, packName), lang && (Y.Env.lang = Y.Env.lang || {}, Y.Env.lang[lang] = Y.Env.lang[lang] || {}, Y.Env.lang[lang][name] = !0)), this.moduleInfo[packName];
|
|
},
|
|
_setup: function() {
|
|
var name, i, j, m, l, packName, info = this.moduleInfo;
|
|
for(name in info)info.hasOwnProperty(name) && (m = info[name]) && (m.requires = yArray.dedupe(m.requires), m.lang && (packName = this.getLangPackName('', name), this._addLangPack(null, m, packName)));
|
|
for(j in l = {}, this.ignoreRegistered || Y.mix(l, GLOBAL_ENV.mods), this.ignore && Y.mix(l, yArray.hash(this.ignore)), l)l.hasOwnProperty(j) && Y.mix(l, this.getProvides(j));
|
|
if (this.force) for(i = 0; i < this.force.length; i++)this.force[i] in l && delete l[this.force[i]];
|
|
Y.mix(this.loaded, l), this._init = !0;
|
|
},
|
|
getLangPackName: function(lang, mname) {
|
|
return 'lang/' + mname + (lang ? '_' + lang : '');
|
|
},
|
|
_explode: function() {
|
|
var m, reqs, name, expound, r = this.required, done = {}, self = this;
|
|
for(name in self.dirty = !1, self._explodeRollups(), r = self.required)r.hasOwnProperty(name) && !done[name] && (done[name] = !0, (m = self.getModule(name)) && ((expound = m.expound) && (r[expound] = self.getModule(expound), reqs = self.getRequires(r[expound]), Y.mix(r, yArray.hash(reqs))), reqs = self.getRequires(m), Y.mix(r, yArray.hash(reqs))));
|
|
},
|
|
_patternTest: function(mname, pname) {
|
|
return mname.indexOf(pname) > -1;
|
|
},
|
|
getModule: function(mname) {
|
|
if (!mname) return null;
|
|
var p, found, pname, m = this.moduleInfo[mname], patterns = this.patterns;
|
|
if (!m || m && m.ext) {
|
|
for(pname in patterns)if (patterns.hasOwnProperty(pname) && ((p = patterns[pname]).test || (p.test = this._patternTest), p.test(mname, pname))) {
|
|
found = p;
|
|
break;
|
|
}
|
|
}
|
|
return m ? found && m && found.configFn && !m.configFn && (m.configFn = found.configFn, m.configFn(m)) : found && (p.action ? p.action.call(this, mname, pname) : (m = this.addModule(Y.merge(found), mname), found.configFn && (m.configFn = found.configFn), m.temp = !0)), m;
|
|
},
|
|
_rollup: function() {},
|
|
_reduce: function(r) {
|
|
r = r || this.required;
|
|
var i, j, s, m, type = this.loadType, ignore = !!this.ignore && yArray.hash(this.ignore);
|
|
for(i in r)if (r.hasOwnProperty(i) && (m = this.getModule(i), ((this.loaded[i] || ON_PAGE[i]) && !this.forceMap[i] && !this.ignoreRegistered || type && m && m.type !== type) && delete r[i], ignore && ignore[i] && delete r[i], s = m && m.supersedes)) for(j = 0; j < s.length; j++)s[j] in r && delete r[s[j]];
|
|
return r;
|
|
},
|
|
_finish: function(msg, success) {
|
|
_queue.running = !1;
|
|
var onEnd = this.onEnd;
|
|
onEnd && onEnd.call(this.context, {
|
|
msg: msg,
|
|
data: this.data,
|
|
success: success
|
|
}), this._continue();
|
|
},
|
|
_onSuccess: function() {
|
|
var fn, success, msg, i, mod, self = this, skipped = Y.merge(self.skipped), failed = [], rreg = self.requireRegistration;
|
|
for(i in skipped)skipped.hasOwnProperty(i) && delete self.inserted[i];
|
|
for(i in self.skipped = {}, self.inserted)self.inserted.hasOwnProperty(i) && ((mod = self.getModule(i)) && rreg && 'js' === mod.type && !(i in YUI.Env.mods) ? failed.push(i) : Y.mix(self.loaded, self.getProvides(i)));
|
|
fn = self.onSuccess, msg = failed.length ? 'notregistered' : 'success', success = !failed.length, fn && fn.call(self.context, {
|
|
msg: msg,
|
|
data: self.data,
|
|
success: success,
|
|
failed: failed,
|
|
skipped: skipped
|
|
}), self._finish(msg, success);
|
|
},
|
|
_onProgress: function(e) {
|
|
var i;
|
|
if (e.data && e.data.length) for(i = 0; i < e.data.length; i++)e.data[i] = this.getModule(e.data[i].name);
|
|
this.onProgress && this.onProgress.call(this.context, {
|
|
name: e.url,
|
|
data: e.data
|
|
});
|
|
},
|
|
_onFailure: function(o) {
|
|
for(var f = this.onFailure, msg = [], i = 0, len = o.errors.length; i < len; i++)msg.push(o.errors[i].error);
|
|
msg = msg.join(','), f && f.call(this.context, {
|
|
msg: msg,
|
|
data: this.data,
|
|
success: !1
|
|
}), this._finish(msg, !1);
|
|
},
|
|
_onTimeout: function(transaction) {
|
|
var f = this.onTimeout;
|
|
f && f.call(this.context, {
|
|
msg: 'timeout',
|
|
data: this.data,
|
|
success: !1,
|
|
transaction: transaction
|
|
});
|
|
},
|
|
_sort: function() {
|
|
for(var l, a, b, j, k, moved, doneKey, s = YObject.keys(this.required), done = {}, p = 0;;){
|
|
for(l = s.length, moved = !1, j = p; j < l; j++){
|
|
for(a = s[j], k = j + 1; k < l; k++)if (!done[doneKey = a + s[k]] && this._requires(a, s[k])) {
|
|
b = s.splice(k, 1), s.splice(j, 0, b[0]), done[doneKey] = !0, moved = !0;
|
|
break;
|
|
}
|
|
if (moved) break;
|
|
p++;
|
|
}
|
|
if (!moved) break;
|
|
}
|
|
this.sorted = s;
|
|
},
|
|
_insert: function(source, o1, type, skipcalc) {
|
|
source && this._config(source);
|
|
var deps, complete, modules = this.resolve(!skipcalc), self = this, comp = 0, actions = 0, mods = {};
|
|
if (self._refetch = [], type && (modules['js' === type ? 'css' : 'js'] = []), self.fetchCSS || (modules.css = []), modules.js.length && comp++, modules.css.length && comp++, complete = function(d) {
|
|
actions++;
|
|
var fn, modName, resMods, errs = {}, i = 0, o = 0, u = '';
|
|
if (d && d.errors) for(i = 0; i < d.errors.length; i++)errs[u = d.errors[i].request ? d.errors[i].request.url : d.errors[i]] = u;
|
|
if (d && d.data && d.data.length && 'success' === d.type) for(i = 0; i < d.data.length; i++)self.inserted[d.data[i].name] = !0, (d.data[i].lang || d.data[i].skinnable) && (delete self.inserted[d.data[i].name], self._refetch.push(d.data[i].name));
|
|
if (actions === comp) {
|
|
if (self._loading = null, self._refetch.length) {
|
|
for(i = 0; i < self._refetch.length; i++)for(o = 0, deps = self.getRequires(self.getModule(self._refetch[i])); o < deps.length; o++)self.inserted[deps[o]] || (mods[deps[o]] = deps[o]);
|
|
if ((mods = Y.Object.keys(mods)).length) {
|
|
if (self.require(mods), (resMods = self.resolve(!0)).cssMods.length) {
|
|
for(i = 0; i < resMods.cssMods.length; i++)modName = resMods.cssMods[i].name, delete YUI.Env._cssLoaded[modName], self.isCSSLoaded(modName) && (self.inserted[modName] = !0, delete self.required[modName]);
|
|
self.sorted = [], self._sort();
|
|
}
|
|
d = null, self._insert();
|
|
}
|
|
}
|
|
d && d.fn && (fn = d.fn, delete d.fn, fn.call(self, d));
|
|
}
|
|
}, this._loading = !0, !modules.js.length && !modules.css.length) {
|
|
actions = -1, complete({
|
|
fn: self._onSuccess
|
|
});
|
|
return;
|
|
}
|
|
modules.css.length && Y.Get.css(modules.css, {
|
|
data: modules.cssMods,
|
|
attributes: self.cssAttributes,
|
|
insertBefore: self.insertBefore,
|
|
charset: self.charset,
|
|
timeout: self.timeout,
|
|
context: self,
|
|
onProgress: function(e) {
|
|
self._onProgress.call(self, e);
|
|
},
|
|
onTimeout: function(d) {
|
|
self._onTimeout.call(self, d);
|
|
},
|
|
onSuccess: function(d) {
|
|
d.type = 'success', d.fn = self._onSuccess, complete.call(self, d);
|
|
},
|
|
onFailure: function(d) {
|
|
d.type = 'failure', d.fn = self._onFailure, complete.call(self, d);
|
|
}
|
|
}), modules.js.length && Y.Get.js(modules.js, {
|
|
data: modules.jsMods,
|
|
insertBefore: self.insertBefore,
|
|
attributes: self.jsAttributes,
|
|
charset: self.charset,
|
|
timeout: self.timeout,
|
|
autopurge: !1,
|
|
context: self,
|
|
async: self.async,
|
|
onProgress: function(e) {
|
|
self._onProgress.call(self, e);
|
|
},
|
|
onTimeout: function(d) {
|
|
self._onTimeout.call(self, d);
|
|
},
|
|
onSuccess: function(d) {
|
|
d.type = 'success', d.fn = self._onSuccess, complete.call(self, d);
|
|
},
|
|
onFailure: function(d) {
|
|
d.type = 'failure', d.fn = self._onFailure, complete.call(self, d);
|
|
}
|
|
});
|
|
},
|
|
_continue: function() {
|
|
!_queue.running && _queue.size() > 0 && (_queue.running = !0, _queue.next()());
|
|
},
|
|
insert: function(o, type, skipsort) {
|
|
var self = this, copy = Y.merge(this);
|
|
delete copy.require, delete copy.dirty, _queue.add(function() {
|
|
self._insert(copy, o, type, skipsort);
|
|
}), this._continue();
|
|
},
|
|
loadNext: function() {},
|
|
_filter: function(u, name, group) {
|
|
var f = this.filter, hasFilter = name && name in this.filters, modFilter = hasFilter && this.filters[name], groupName = group || (this.moduleInfo[name] ? this.moduleInfo[name].group : null);
|
|
return groupName && this.groups[groupName] && this.groups[groupName].filter && (modFilter = this.groups[groupName].filter, hasFilter = !0), u && (hasFilter && (f = L.isString(modFilter) ? this.FILTER_DEFS[modFilter.toUpperCase()] || null : modFilter), f && (u = u.replace(new RegExp(f.searchExp, 'g'), f.replaceStr))), u;
|
|
},
|
|
_url: function(path, name, base) {
|
|
return this._filter((base || this.base || '') + path, name);
|
|
},
|
|
resolve: function(calc, s) {
|
|
var len, i, m1, url, group, groupName, j, frag, comboSource, comboSources, mods, comboBase, base, urls, tmpBase, baseLen, comboSep, maxURLLength, addSingle, u = [], resCombos = {}, self = this, inserted = self.ignoreRegistered ? {} : self.inserted, resolved = {
|
|
js: [],
|
|
jsMods: [],
|
|
css: [],
|
|
cssMods: []
|
|
}, type = self.loadType || 'js';
|
|
for((self.skin.overrides || 'sam' !== self.skin.defaultSkin || self.ignoreRegistered) && self._resetModules(), calc && self.calculate(), s = s || self.sorted, addSingle = function(m) {
|
|
m && (!1 === (group = m.group && self.groups[m.group] || NOT_FOUND).async && (m.async = group.async), url = m.fullpath ? self._filter(m.fullpath, s[i]) : self._url(m.path, s[i], group.base || m.base), (m.attributes || !1 === m.async) && (url = {
|
|
url: url,
|
|
async: m.async
|
|
}, m.attributes && (url.attributes = m.attributes)), resolved[m.type].push(url), resolved[m.type + 'Mods'].push(m));
|
|
}, len = s.length, url = comboBase = self.comboBase, comboSources = {}, i = 0; i < len; i++){
|
|
if (comboSource = comboBase, groupName = (m1 = self.getModule(s[i])) && m1.group, group = self.groups[groupName], groupName && group) {
|
|
if (!group.combine || m1.fullpath) {
|
|
addSingle(m1);
|
|
continue;
|
|
}
|
|
m1.combine = !0, group.comboBase && (comboSource = group.comboBase), "root" in group && L.isValue(group.root) && (m1.root = group.root), m1.comboSep = group.comboSep || self.comboSep, m1.maxURLLength = group.maxURLLength || self.maxURLLength;
|
|
} else if (!self.combine) {
|
|
addSingle(m1);
|
|
continue;
|
|
}
|
|
comboSources[comboSource] = comboSources[comboSource] || [], comboSources[comboSource].push(m1);
|
|
}
|
|
for(j in comboSources)if (comboSources.hasOwnProperty(j) && (resCombos[j] = resCombos[j] || {
|
|
js: [],
|
|
jsMods: [],
|
|
css: [],
|
|
cssMods: []
|
|
}, url = j, mods = comboSources[j], len = mods.length)) for(i = 0; i < len; i++)!inserted[mods[i]] && ((m1 = mods[i]) && (m1.combine || !m1.ext) ? (resCombos[j].comboSep = m1.comboSep, resCombos[j].group = m1.group, resCombos[j].maxURLLength = m1.maxURLLength, frag = (L.isValue(m1.root) ? m1.root : self.root) + (m1.path || m1.fullpath), frag = self._filter(frag, m1.name), resCombos[j][m1.type].push(frag), resCombos[j][m1.type + 'Mods'].push(m1)) : mods[i] && addSingle(mods[i]));
|
|
for(j in resCombos)if (resCombos.hasOwnProperty(j)) {
|
|
for(type in comboSep = resCombos[base = j].comboSep || self.comboSep, maxURLLength = resCombos[base].maxURLLength || self.maxURLLength, resCombos[base])if ('js' === type || 'css' === type) {
|
|
if (urls = resCombos[base][type], mods = resCombos[base][type + 'Mods'], len = urls.length, tmpBase = base + urls.join(comboSep), baseLen = tmpBase.length, maxURLLength <= base.length && (maxURLLength = 1024), len) {
|
|
if (baseLen > maxURLLength) {
|
|
for(s = 0, u = []; s < len; s++)u.push(urls[s]), (tmpBase = base + u.join(comboSep)).length > maxURLLength && (m1 = u.pop(), tmpBase = base + u.join(comboSep), resolved[type].push(self._filter(tmpBase, null, resCombos[base].group)), u = [], m1 && u.push(m1));
|
|
u.length && (tmpBase = base + u.join(comboSep), resolved[type].push(self._filter(tmpBase, null, resCombos[base].group)));
|
|
} else resolved[type].push(self._filter(tmpBase, null, resCombos[base].group));
|
|
}
|
|
resolved[type + 'Mods'] = resolved[type + 'Mods'].concat(mods);
|
|
}
|
|
}
|
|
return resCombos = null, resolved;
|
|
},
|
|
load: function(cb) {
|
|
if (cb) {
|
|
var self = this, out = self.resolve(!0);
|
|
self.data = out, self.onEnd = function() {
|
|
cb.apply(self.context || self, arguments);
|
|
}, self.insert();
|
|
}
|
|
}
|
|
};
|
|
}, '3.12.0', {
|
|
requires: [
|
|
"get",
|
|
"features"
|
|
]
|
|
}), YUI.add('loader-rollup', function(Y, NAME) {
|
|
Y.Loader.prototype._rollup = function() {
|
|
var i, j, m, s, roll, rolled, c, smod, r = this.required, info = this.moduleInfo;
|
|
if (this.dirty || !this.rollups) for(i in this.rollups = {}, info)info.hasOwnProperty(i) && (m = this.getModule(i)) && m.rollup && (this.rollups[i] = m);
|
|
for(;;){
|
|
for(i in rolled = !1, this.rollups)if (this.rollups.hasOwnProperty(i) && !r[i] && (!this.loaded[i] || this.forceMap[i])) {
|
|
if (s = (m = this.getModule(i)).supersedes || [], roll = !1, !m.rollup) continue;
|
|
for(j = 0, c = 0; j < s.length; j++){
|
|
if (smod = info[s[j]], this.loaded[s[j]] && !this.forceMap[s[j]]) {
|
|
roll = !1;
|
|
break;
|
|
}
|
|
if (r[s[j]] && m.type === smod.type && (roll = ++c >= m.rollup)) break;
|
|
}
|
|
roll && (r[i] = !0, rolled = !0, this.getRequires(m));
|
|
}
|
|
if (!rolled) break;
|
|
}
|
|
};
|
|
}, '3.12.0', {
|
|
requires: [
|
|
"loader-base"
|
|
]
|
|
}), YUI.add('loader-yui3', function(Y4, NAME) {
|
|
YUI.Env[Y4.version].modules = YUI.Env[Y4.version].modules || {}, Y4.mix(YUI.Env[Y4.version].modules, {
|
|
"align-plugin": {
|
|
requires: [
|
|
"node-screen",
|
|
"node-pluginhost"
|
|
]
|
|
},
|
|
anim: {
|
|
use: [
|
|
"anim-base",
|
|
"anim-color",
|
|
"anim-curve",
|
|
"anim-easing",
|
|
"anim-node-plugin",
|
|
"anim-scroll",
|
|
"anim-xy"
|
|
]
|
|
},
|
|
"anim-base": {
|
|
requires: [
|
|
"base-base",
|
|
"node-style"
|
|
]
|
|
},
|
|
"anim-color": {
|
|
requires: [
|
|
"anim-base"
|
|
]
|
|
},
|
|
"anim-curve": {
|
|
requires: [
|
|
"anim-xy"
|
|
]
|
|
},
|
|
"anim-easing": {
|
|
requires: [
|
|
"anim-base"
|
|
]
|
|
},
|
|
"anim-node-plugin": {
|
|
requires: [
|
|
"node-pluginhost",
|
|
"anim-base"
|
|
]
|
|
},
|
|
"anim-scroll": {
|
|
requires: [
|
|
"anim-base"
|
|
]
|
|
},
|
|
"anim-shape": {
|
|
requires: [
|
|
"anim-base",
|
|
"anim-easing",
|
|
"anim-color",
|
|
"matrix"
|
|
]
|
|
},
|
|
"anim-shape-transform": {
|
|
use: [
|
|
"anim-shape"
|
|
]
|
|
},
|
|
"anim-xy": {
|
|
requires: [
|
|
"anim-base",
|
|
"node-screen"
|
|
]
|
|
},
|
|
app: {
|
|
use: [
|
|
"app-base",
|
|
"app-content",
|
|
"app-transitions",
|
|
"lazy-model-list",
|
|
"model",
|
|
"model-list",
|
|
"model-sync-rest",
|
|
"router",
|
|
"view",
|
|
"view-node-map"
|
|
]
|
|
},
|
|
"app-base": {
|
|
requires: [
|
|
"classnamemanager",
|
|
"pjax-base",
|
|
"router",
|
|
"view"
|
|
]
|
|
},
|
|
"app-content": {
|
|
requires: [
|
|
"app-base",
|
|
"pjax-content"
|
|
]
|
|
},
|
|
"app-transitions": {
|
|
requires: [
|
|
"app-base"
|
|
]
|
|
},
|
|
"app-transitions-css": {
|
|
type: "css"
|
|
},
|
|
"app-transitions-native": {
|
|
condition: {
|
|
name: "app-transitions-native",
|
|
test: function(Y) {
|
|
var doc = Y.config.doc, node = doc ? doc.documentElement : null;
|
|
return !!node && !!node.style && ('MozTransition' in node.style || 'WebkitTransition' in node.style || 'transition' in node.style);
|
|
},
|
|
trigger: "app-transitions"
|
|
},
|
|
requires: [
|
|
"app-transitions",
|
|
"app-transitions-css",
|
|
"parallel",
|
|
"transition"
|
|
]
|
|
},
|
|
"array-extras": {
|
|
requires: [
|
|
"yui-base"
|
|
]
|
|
},
|
|
"array-invoke": {
|
|
requires: [
|
|
"yui-base"
|
|
]
|
|
},
|
|
arraylist: {
|
|
requires: [
|
|
"yui-base"
|
|
]
|
|
},
|
|
"arraylist-add": {
|
|
requires: [
|
|
"arraylist"
|
|
]
|
|
},
|
|
"arraylist-filter": {
|
|
requires: [
|
|
"arraylist"
|
|
]
|
|
},
|
|
arraysort: {
|
|
requires: [
|
|
"yui-base"
|
|
]
|
|
},
|
|
"async-queue": {
|
|
requires: [
|
|
"event-custom"
|
|
]
|
|
},
|
|
attribute: {
|
|
use: [
|
|
"attribute-base",
|
|
"attribute-complex"
|
|
]
|
|
},
|
|
"attribute-base": {
|
|
requires: [
|
|
"attribute-core",
|
|
"attribute-observable",
|
|
"attribute-extras"
|
|
]
|
|
},
|
|
"attribute-complex": {
|
|
requires: [
|
|
"attribute-base"
|
|
]
|
|
},
|
|
"attribute-core": {
|
|
requires: [
|
|
"oop"
|
|
]
|
|
},
|
|
"attribute-events": {
|
|
use: [
|
|
"attribute-observable"
|
|
]
|
|
},
|
|
"attribute-extras": {
|
|
requires: [
|
|
"oop"
|
|
]
|
|
},
|
|
"attribute-observable": {
|
|
requires: [
|
|
"event-custom"
|
|
]
|
|
},
|
|
autocomplete: {
|
|
use: [
|
|
"autocomplete-base",
|
|
"autocomplete-sources",
|
|
"autocomplete-list",
|
|
"autocomplete-plugin"
|
|
]
|
|
},
|
|
"autocomplete-base": {
|
|
optional: [
|
|
"autocomplete-sources"
|
|
],
|
|
requires: [
|
|
"array-extras",
|
|
"base-build",
|
|
"escape",
|
|
"event-valuechange",
|
|
"node-base"
|
|
]
|
|
},
|
|
"autocomplete-filters": {
|
|
requires: [
|
|
"array-extras",
|
|
"text-wordbreak"
|
|
]
|
|
},
|
|
"autocomplete-filters-accentfold": {
|
|
requires: [
|
|
"array-extras",
|
|
"text-accentfold",
|
|
"text-wordbreak"
|
|
]
|
|
},
|
|
"autocomplete-highlighters": {
|
|
requires: [
|
|
"array-extras",
|
|
"highlight-base"
|
|
]
|
|
},
|
|
"autocomplete-highlighters-accentfold": {
|
|
requires: [
|
|
"array-extras",
|
|
"highlight-accentfold"
|
|
]
|
|
},
|
|
"autocomplete-list": {
|
|
after: [
|
|
"autocomplete-sources"
|
|
],
|
|
lang: [
|
|
"en",
|
|
"es",
|
|
"hu",
|
|
"it"
|
|
],
|
|
requires: [
|
|
"autocomplete-base",
|
|
"event-resize",
|
|
"node-screen",
|
|
"selector-css3",
|
|
"shim-plugin",
|
|
"widget",
|
|
"widget-position",
|
|
"widget-position-align"
|
|
],
|
|
skinnable: !0
|
|
},
|
|
"autocomplete-list-keys": {
|
|
condition: {
|
|
name: "autocomplete-list-keys",
|
|
test: function(Y) {
|
|
return !(Y.UA.ios || Y.UA.android);
|
|
},
|
|
trigger: "autocomplete-list"
|
|
},
|
|
requires: [
|
|
"autocomplete-list",
|
|
"base-build"
|
|
]
|
|
},
|
|
"autocomplete-plugin": {
|
|
requires: [
|
|
"autocomplete-list",
|
|
"node-pluginhost"
|
|
]
|
|
},
|
|
"autocomplete-sources": {
|
|
optional: [
|
|
"io-base",
|
|
"json-parse",
|
|
"jsonp",
|
|
"yql"
|
|
],
|
|
requires: [
|
|
"autocomplete-base"
|
|
]
|
|
},
|
|
axes: {
|
|
use: [
|
|
"axis-numeric",
|
|
"axis-category",
|
|
"axis-time",
|
|
"axis-stacked"
|
|
]
|
|
},
|
|
"axes-base": {
|
|
use: [
|
|
"axis-numeric-base",
|
|
"axis-category-base",
|
|
"axis-time-base",
|
|
"axis-stacked-base"
|
|
]
|
|
},
|
|
axis: {
|
|
requires: [
|
|
"dom",
|
|
"widget",
|
|
"widget-position",
|
|
"widget-stack",
|
|
"graphics",
|
|
"axis-base"
|
|
]
|
|
},
|
|
"axis-base": {
|
|
requires: [
|
|
"classnamemanager",
|
|
"datatype-number",
|
|
"datatype-date",
|
|
"base",
|
|
"event-custom"
|
|
]
|
|
},
|
|
"axis-category": {
|
|
requires: [
|
|
"axis",
|
|
"axis-category-base"
|
|
]
|
|
},
|
|
"axis-category-base": {
|
|
requires: [
|
|
"axis-base"
|
|
]
|
|
},
|
|
"axis-numeric": {
|
|
requires: [
|
|
"axis",
|
|
"axis-numeric-base"
|
|
]
|
|
},
|
|
"axis-numeric-base": {
|
|
requires: [
|
|
"axis-base"
|
|
]
|
|
},
|
|
"axis-stacked": {
|
|
requires: [
|
|
"axis-numeric",
|
|
"axis-stacked-base"
|
|
]
|
|
},
|
|
"axis-stacked-base": {
|
|
requires: [
|
|
"axis-numeric-base"
|
|
]
|
|
},
|
|
"axis-time": {
|
|
requires: [
|
|
"axis",
|
|
"axis-time-base"
|
|
]
|
|
},
|
|
"axis-time-base": {
|
|
requires: [
|
|
"axis-base"
|
|
]
|
|
},
|
|
base: {
|
|
use: [
|
|
"base-base",
|
|
"base-pluginhost",
|
|
"base-build"
|
|
]
|
|
},
|
|
"base-base": {
|
|
requires: [
|
|
"attribute-base",
|
|
"base-core",
|
|
"base-observable"
|
|
]
|
|
},
|
|
"base-build": {
|
|
requires: [
|
|
"base-base"
|
|
]
|
|
},
|
|
"base-core": {
|
|
requires: [
|
|
"attribute-core"
|
|
]
|
|
},
|
|
"base-observable": {
|
|
requires: [
|
|
"attribute-observable"
|
|
]
|
|
},
|
|
"base-pluginhost": {
|
|
requires: [
|
|
"base-base",
|
|
"pluginhost"
|
|
]
|
|
},
|
|
button: {
|
|
requires: [
|
|
"button-core",
|
|
"cssbutton",
|
|
"widget"
|
|
]
|
|
},
|
|
"button-core": {
|
|
requires: [
|
|
"attribute-core",
|
|
"classnamemanager",
|
|
"node-base"
|
|
]
|
|
},
|
|
"button-group": {
|
|
requires: [
|
|
"button-plugin",
|
|
"cssbutton",
|
|
"widget"
|
|
]
|
|
},
|
|
"button-plugin": {
|
|
requires: [
|
|
"button-core",
|
|
"cssbutton",
|
|
"node-pluginhost"
|
|
]
|
|
},
|
|
cache: {
|
|
use: [
|
|
"cache-base",
|
|
"cache-offline",
|
|
"cache-plugin"
|
|
]
|
|
},
|
|
"cache-base": {
|
|
requires: [
|
|
"base"
|
|
]
|
|
},
|
|
"cache-offline": {
|
|
requires: [
|
|
"cache-base",
|
|
"json"
|
|
]
|
|
},
|
|
"cache-plugin": {
|
|
requires: [
|
|
"plugin",
|
|
"cache-base"
|
|
]
|
|
},
|
|
calendar: {
|
|
requires: [
|
|
"calendar-base",
|
|
"calendarnavigator"
|
|
],
|
|
skinnable: !0
|
|
},
|
|
"calendar-base": {
|
|
lang: [
|
|
"de",
|
|
"en",
|
|
"es",
|
|
"es-AR",
|
|
"fr",
|
|
"hu",
|
|
"it",
|
|
"ja",
|
|
"nb-NO",
|
|
"nl",
|
|
"pt-BR",
|
|
"ru",
|
|
"zh-Hans",
|
|
"zh-Hans-CN",
|
|
"zh-Hant",
|
|
"zh-Hant-HK",
|
|
"zh-HANT-TW"
|
|
],
|
|
requires: [
|
|
"widget",
|
|
"datatype-date",
|
|
"datatype-date-math",
|
|
"cssgrids"
|
|
],
|
|
skinnable: !0
|
|
},
|
|
calendarnavigator: {
|
|
requires: [
|
|
"plugin",
|
|
"classnamemanager",
|
|
"datatype-date",
|
|
"node"
|
|
],
|
|
skinnable: !0
|
|
},
|
|
charts: {
|
|
use: [
|
|
"charts-base"
|
|
]
|
|
},
|
|
"charts-base": {
|
|
requires: [
|
|
"dom",
|
|
"event-mouseenter",
|
|
"event-touch",
|
|
"graphics-group",
|
|
"axes",
|
|
"series-pie",
|
|
"series-line",
|
|
"series-marker",
|
|
"series-area",
|
|
"series-spline",
|
|
"series-column",
|
|
"series-bar",
|
|
"series-areaspline",
|
|
"series-combo",
|
|
"series-combospline",
|
|
"series-line-stacked",
|
|
"series-marker-stacked",
|
|
"series-area-stacked",
|
|
"series-spline-stacked",
|
|
"series-column-stacked",
|
|
"series-bar-stacked",
|
|
"series-areaspline-stacked",
|
|
"series-combo-stacked",
|
|
"series-combospline-stacked"
|
|
]
|
|
},
|
|
"charts-legend": {
|
|
requires: [
|
|
"charts-base"
|
|
]
|
|
},
|
|
classnamemanager: {
|
|
requires: [
|
|
"yui-base"
|
|
]
|
|
},
|
|
"clickable-rail": {
|
|
requires: [
|
|
"slider-base"
|
|
]
|
|
},
|
|
collection: {
|
|
use: [
|
|
"array-extras",
|
|
"arraylist",
|
|
"arraylist-add",
|
|
"arraylist-filter",
|
|
"array-invoke"
|
|
]
|
|
},
|
|
color: {
|
|
use: [
|
|
"color-base",
|
|
"color-hsl",
|
|
"color-harmony"
|
|
]
|
|
},
|
|
"color-base": {
|
|
requires: [
|
|
"yui-base"
|
|
]
|
|
},
|
|
"color-harmony": {
|
|
requires: [
|
|
"color-hsl"
|
|
]
|
|
},
|
|
"color-hsl": {
|
|
requires: [
|
|
"color-base"
|
|
]
|
|
},
|
|
"color-hsv": {
|
|
requires: [
|
|
"color-base"
|
|
]
|
|
},
|
|
console: {
|
|
lang: [
|
|
"en",
|
|
"es",
|
|
"hu",
|
|
"it",
|
|
"ja"
|
|
],
|
|
requires: [
|
|
"yui-log",
|
|
"widget"
|
|
],
|
|
skinnable: !0
|
|
},
|
|
"console-filters": {
|
|
requires: [
|
|
"plugin",
|
|
"console"
|
|
],
|
|
skinnable: !0
|
|
},
|
|
controller: {
|
|
use: [
|
|
"router"
|
|
]
|
|
},
|
|
cookie: {
|
|
requires: [
|
|
"yui-base"
|
|
]
|
|
},
|
|
"createlink-base": {
|
|
requires: [
|
|
"editor-base"
|
|
]
|
|
},
|
|
cssbase: {
|
|
after: [
|
|
"cssreset",
|
|
"cssfonts",
|
|
"cssgrids",
|
|
"cssreset-context",
|
|
"cssfonts-context",
|
|
"cssgrids-context"
|
|
],
|
|
type: "css"
|
|
},
|
|
"cssbase-context": {
|
|
after: [
|
|
"cssreset",
|
|
"cssfonts",
|
|
"cssgrids",
|
|
"cssreset-context",
|
|
"cssfonts-context",
|
|
"cssgrids-context"
|
|
],
|
|
type: "css"
|
|
},
|
|
cssbutton: {
|
|
type: "css"
|
|
},
|
|
cssfonts: {
|
|
type: "css"
|
|
},
|
|
"cssfonts-context": {
|
|
type: "css"
|
|
},
|
|
cssgrids: {
|
|
optional: [
|
|
"cssnormalize"
|
|
],
|
|
type: "css"
|
|
},
|
|
"cssgrids-base": {
|
|
optional: [
|
|
"cssnormalize"
|
|
],
|
|
type: "css"
|
|
},
|
|
"cssgrids-responsive": {
|
|
optional: [
|
|
"cssnormalize"
|
|
],
|
|
requires: [
|
|
"cssgrids",
|
|
"cssgrids-responsive-base"
|
|
],
|
|
type: "css"
|
|
},
|
|
"cssgrids-units": {
|
|
optional: [
|
|
"cssnormalize"
|
|
],
|
|
requires: [
|
|
"cssgrids-base"
|
|
],
|
|
type: "css"
|
|
},
|
|
cssnormalize: {
|
|
type: "css"
|
|
},
|
|
"cssnormalize-context": {
|
|
type: "css"
|
|
},
|
|
cssreset: {
|
|
type: "css"
|
|
},
|
|
"cssreset-context": {
|
|
type: "css"
|
|
},
|
|
dataschema: {
|
|
use: [
|
|
"dataschema-base",
|
|
"dataschema-json",
|
|
"dataschema-xml",
|
|
"dataschema-array",
|
|
"dataschema-text"
|
|
]
|
|
},
|
|
"dataschema-array": {
|
|
requires: [
|
|
"dataschema-base"
|
|
]
|
|
},
|
|
"dataschema-base": {
|
|
requires: [
|
|
"base"
|
|
]
|
|
},
|
|
"dataschema-json": {
|
|
requires: [
|
|
"dataschema-base",
|
|
"json"
|
|
]
|
|
},
|
|
"dataschema-text": {
|
|
requires: [
|
|
"dataschema-base"
|
|
]
|
|
},
|
|
"dataschema-xml": {
|
|
requires: [
|
|
"dataschema-base"
|
|
]
|
|
},
|
|
datasource: {
|
|
use: [
|
|
"datasource-local",
|
|
"datasource-io",
|
|
"datasource-get",
|
|
"datasource-function",
|
|
"datasource-cache",
|
|
"datasource-jsonschema",
|
|
"datasource-xmlschema",
|
|
"datasource-arrayschema",
|
|
"datasource-textschema",
|
|
"datasource-polling"
|
|
]
|
|
},
|
|
"datasource-arrayschema": {
|
|
requires: [
|
|
"datasource-local",
|
|
"plugin",
|
|
"dataschema-array"
|
|
]
|
|
},
|
|
"datasource-cache": {
|
|
requires: [
|
|
"datasource-local",
|
|
"plugin",
|
|
"cache-base"
|
|
]
|
|
},
|
|
"datasource-function": {
|
|
requires: [
|
|
"datasource-local"
|
|
]
|
|
},
|
|
"datasource-get": {
|
|
requires: [
|
|
"datasource-local",
|
|
"get"
|
|
]
|
|
},
|
|
"datasource-io": {
|
|
requires: [
|
|
"datasource-local",
|
|
"io-base"
|
|
]
|
|
},
|
|
"datasource-jsonschema": {
|
|
requires: [
|
|
"datasource-local",
|
|
"plugin",
|
|
"dataschema-json"
|
|
]
|
|
},
|
|
"datasource-local": {
|
|
requires: [
|
|
"base"
|
|
]
|
|
},
|
|
"datasource-polling": {
|
|
requires: [
|
|
"datasource-local"
|
|
]
|
|
},
|
|
"datasource-textschema": {
|
|
requires: [
|
|
"datasource-local",
|
|
"plugin",
|
|
"dataschema-text"
|
|
]
|
|
},
|
|
"datasource-xmlschema": {
|
|
requires: [
|
|
"datasource-local",
|
|
"plugin",
|
|
"datatype-xml",
|
|
"dataschema-xml"
|
|
]
|
|
},
|
|
datatable: {
|
|
use: [
|
|
"datatable-core",
|
|
"datatable-table",
|
|
"datatable-head",
|
|
"datatable-body",
|
|
"datatable-base",
|
|
"datatable-column-widths",
|
|
"datatable-message",
|
|
"datatable-mutable",
|
|
"datatable-sort",
|
|
"datatable-datasource"
|
|
]
|
|
},
|
|
"datatable-base": {
|
|
requires: [
|
|
"datatable-core",
|
|
"datatable-table",
|
|
"datatable-head",
|
|
"datatable-body",
|
|
"base-build",
|
|
"widget"
|
|
],
|
|
skinnable: !0
|
|
},
|
|
"datatable-body": {
|
|
requires: [
|
|
"datatable-core",
|
|
"view",
|
|
"classnamemanager"
|
|
]
|
|
},
|
|
"datatable-column-widths": {
|
|
requires: [
|
|
"datatable-base"
|
|
]
|
|
},
|
|
"datatable-core": {
|
|
requires: [
|
|
"escape",
|
|
"model-list",
|
|
"node-event-delegate"
|
|
]
|
|
},
|
|
"datatable-datasource": {
|
|
requires: [
|
|
"datatable-base",
|
|
"plugin",
|
|
"datasource-local"
|
|
]
|
|
},
|
|
"datatable-foot": {
|
|
requires: [
|
|
"datatable-core",
|
|
"view"
|
|
]
|
|
},
|
|
"datatable-formatters": {
|
|
requires: [
|
|
"datatable-body",
|
|
"datatype-number-format",
|
|
"datatype-date-format",
|
|
"escape"
|
|
]
|
|
},
|
|
"datatable-head": {
|
|
requires: [
|
|
"datatable-core",
|
|
"view",
|
|
"classnamemanager"
|
|
]
|
|
},
|
|
"datatable-message": {
|
|
lang: [
|
|
"en",
|
|
"fr",
|
|
"es",
|
|
"hu",
|
|
"it"
|
|
],
|
|
requires: [
|
|
"datatable-base"
|
|
],
|
|
skinnable: !0
|
|
},
|
|
"datatable-mutable": {
|
|
requires: [
|
|
"datatable-base"
|
|
]
|
|
},
|
|
"datatable-paginator": {
|
|
lang: [
|
|
"en"
|
|
],
|
|
requires: [
|
|
"model",
|
|
"view",
|
|
"paginator-core",
|
|
"datatable-foot",
|
|
"datatable-paginator-templates"
|
|
],
|
|
skinnable: !0
|
|
},
|
|
"datatable-paginator-templates": {
|
|
requires: [
|
|
"template"
|
|
]
|
|
},
|
|
"datatable-scroll": {
|
|
requires: [
|
|
"datatable-base",
|
|
"datatable-column-widths",
|
|
"dom-screen"
|
|
],
|
|
skinnable: !0
|
|
},
|
|
"datatable-sort": {
|
|
lang: [
|
|
"en",
|
|
"fr",
|
|
"es",
|
|
"hu"
|
|
],
|
|
requires: [
|
|
"datatable-base"
|
|
],
|
|
skinnable: !0
|
|
},
|
|
"datatable-table": {
|
|
requires: [
|
|
"datatable-core",
|
|
"datatable-head",
|
|
"datatable-body",
|
|
"view",
|
|
"classnamemanager"
|
|
]
|
|
},
|
|
datatype: {
|
|
use: [
|
|
"datatype-date",
|
|
"datatype-number",
|
|
"datatype-xml"
|
|
]
|
|
},
|
|
"datatype-date": {
|
|
use: [
|
|
"datatype-date-parse",
|
|
"datatype-date-format",
|
|
"datatype-date-math"
|
|
]
|
|
},
|
|
"datatype-date-format": {
|
|
lang: [
|
|
"ar",
|
|
"ar-JO",
|
|
"ca",
|
|
"ca-ES",
|
|
"da",
|
|
"da-DK",
|
|
"de",
|
|
"de-AT",
|
|
"de-DE",
|
|
"el",
|
|
"el-GR",
|
|
"en",
|
|
"en-AU",
|
|
"en-CA",
|
|
"en-GB",
|
|
"en-IE",
|
|
"en-IN",
|
|
"en-JO",
|
|
"en-MY",
|
|
"en-NZ",
|
|
"en-PH",
|
|
"en-SG",
|
|
"en-US",
|
|
"es",
|
|
"es-AR",
|
|
"es-BO",
|
|
"es-CL",
|
|
"es-CO",
|
|
"es-EC",
|
|
"es-ES",
|
|
"es-MX",
|
|
"es-PE",
|
|
"es-PY",
|
|
"es-US",
|
|
"es-UY",
|
|
"es-VE",
|
|
"fi",
|
|
"fi-FI",
|
|
"fr",
|
|
"fr-BE",
|
|
"fr-CA",
|
|
"fr-FR",
|
|
"hi",
|
|
"hi-IN",
|
|
"hu",
|
|
"id",
|
|
"id-ID",
|
|
"it",
|
|
"it-IT",
|
|
"ja",
|
|
"ja-JP",
|
|
"ko",
|
|
"ko-KR",
|
|
"ms",
|
|
"ms-MY",
|
|
"nb",
|
|
"nb-NO",
|
|
"nl",
|
|
"nl-BE",
|
|
"nl-NL",
|
|
"pl",
|
|
"pl-PL",
|
|
"pt",
|
|
"pt-BR",
|
|
"ro",
|
|
"ro-RO",
|
|
"ru",
|
|
"ru-RU",
|
|
"sv",
|
|
"sv-SE",
|
|
"th",
|
|
"th-TH",
|
|
"tr",
|
|
"tr-TR",
|
|
"vi",
|
|
"vi-VN",
|
|
"zh-Hans",
|
|
"zh-Hans-CN",
|
|
"zh-Hant",
|
|
"zh-Hant-HK",
|
|
"zh-Hant-TW"
|
|
]
|
|
},
|
|
"datatype-date-math": {
|
|
requires: [
|
|
"yui-base"
|
|
]
|
|
},
|
|
"datatype-date-parse": {},
|
|
"datatype-number": {
|
|
use: [
|
|
"datatype-number-parse",
|
|
"datatype-number-format"
|
|
]
|
|
},
|
|
"datatype-number-format": {},
|
|
"datatype-number-parse": {},
|
|
"datatype-xml": {
|
|
use: [
|
|
"datatype-xml-parse",
|
|
"datatype-xml-format"
|
|
]
|
|
},
|
|
"datatype-xml-format": {},
|
|
"datatype-xml-parse": {},
|
|
dd: {
|
|
use: [
|
|
"dd-ddm-base",
|
|
"dd-ddm",
|
|
"dd-ddm-drop",
|
|
"dd-drag",
|
|
"dd-proxy",
|
|
"dd-constrain",
|
|
"dd-drop",
|
|
"dd-scroll",
|
|
"dd-delegate"
|
|
]
|
|
},
|
|
"dd-constrain": {
|
|
requires: [
|
|
"dd-drag"
|
|
]
|
|
},
|
|
"dd-ddm": {
|
|
requires: [
|
|
"dd-ddm-base",
|
|
"event-resize"
|
|
]
|
|
},
|
|
"dd-ddm-base": {
|
|
requires: [
|
|
"node",
|
|
"base",
|
|
"yui-throttle",
|
|
"classnamemanager"
|
|
]
|
|
},
|
|
"dd-ddm-drop": {
|
|
requires: [
|
|
"dd-ddm"
|
|
]
|
|
},
|
|
"dd-delegate": {
|
|
requires: [
|
|
"dd-drag",
|
|
"dd-drop-plugin",
|
|
"event-mouseenter"
|
|
]
|
|
},
|
|
"dd-drag": {
|
|
requires: [
|
|
"dd-ddm-base"
|
|
]
|
|
},
|
|
"dd-drop": {
|
|
requires: [
|
|
"dd-drag",
|
|
"dd-ddm-drop"
|
|
]
|
|
},
|
|
"dd-drop-plugin": {
|
|
requires: [
|
|
"dd-drop"
|
|
]
|
|
},
|
|
"dd-gestures": {
|
|
condition: {
|
|
name: "dd-gestures",
|
|
trigger: "dd-drag",
|
|
ua: "touchEnabled"
|
|
},
|
|
requires: [
|
|
"dd-drag",
|
|
"event-synthetic",
|
|
"event-gestures"
|
|
]
|
|
},
|
|
"dd-plugin": {
|
|
optional: [
|
|
"dd-constrain",
|
|
"dd-proxy"
|
|
],
|
|
requires: [
|
|
"dd-drag"
|
|
]
|
|
},
|
|
"dd-proxy": {
|
|
requires: [
|
|
"dd-drag"
|
|
]
|
|
},
|
|
"dd-scroll": {
|
|
requires: [
|
|
"dd-drag"
|
|
]
|
|
},
|
|
dial: {
|
|
lang: [
|
|
"en",
|
|
"es",
|
|
"hu"
|
|
],
|
|
requires: [
|
|
"widget",
|
|
"dd-drag",
|
|
"event-mouseenter",
|
|
"event-move",
|
|
"event-key",
|
|
"transition",
|
|
"intl"
|
|
],
|
|
skinnable: !0
|
|
},
|
|
dom: {
|
|
use: [
|
|
"dom-base",
|
|
"dom-screen",
|
|
"dom-style",
|
|
"selector-native",
|
|
"selector"
|
|
]
|
|
},
|
|
"dom-base": {
|
|
requires: [
|
|
"dom-core"
|
|
]
|
|
},
|
|
"dom-core": {
|
|
requires: [
|
|
"oop",
|
|
"features"
|
|
]
|
|
},
|
|
"dom-deprecated": {
|
|
requires: [
|
|
"dom-base"
|
|
]
|
|
},
|
|
"dom-screen": {
|
|
requires: [
|
|
"dom-base",
|
|
"dom-style"
|
|
]
|
|
},
|
|
"dom-style": {
|
|
requires: [
|
|
"dom-base",
|
|
"color-base"
|
|
]
|
|
},
|
|
"dom-style-ie": {
|
|
condition: {
|
|
name: "dom-style-ie",
|
|
test: function(Y) {
|
|
var testFeature = Y.Features.test, addFeature = Y.Features.add, WINDOW = Y.config.win, DOCUMENT = Y.config.doc;
|
|
return addFeature('style', 'computedStyle', {
|
|
test: function() {
|
|
return WINDOW && 'getComputedStyle' in WINDOW;
|
|
}
|
|
}), addFeature('style', 'opacity', {
|
|
test: function() {
|
|
return DOCUMENT && 'opacity' in DOCUMENT.documentElement.style;
|
|
}
|
|
}), !testFeature('style', 'opacity') && !testFeature('style', 'computedStyle');
|
|
},
|
|
trigger: "dom-style"
|
|
},
|
|
requires: [
|
|
"dom-style"
|
|
]
|
|
},
|
|
dump: {
|
|
requires: [
|
|
"yui-base"
|
|
]
|
|
},
|
|
editor: {
|
|
use: [
|
|
"frame",
|
|
"editor-selection",
|
|
"exec-command",
|
|
"editor-base",
|
|
"editor-para",
|
|
"editor-br",
|
|
"editor-bidi",
|
|
"editor-tab",
|
|
"createlink-base"
|
|
]
|
|
},
|
|
"editor-base": {
|
|
requires: [
|
|
"base",
|
|
"frame",
|
|
"node",
|
|
"exec-command",
|
|
"editor-selection"
|
|
]
|
|
},
|
|
"editor-bidi": {
|
|
requires: [
|
|
"editor-base"
|
|
]
|
|
},
|
|
"editor-br": {
|
|
requires: [
|
|
"editor-base"
|
|
]
|
|
},
|
|
"editor-lists": {
|
|
requires: [
|
|
"editor-base"
|
|
]
|
|
},
|
|
"editor-para": {
|
|
requires: [
|
|
"editor-para-base"
|
|
]
|
|
},
|
|
"editor-para-base": {
|
|
requires: [
|
|
"editor-base"
|
|
]
|
|
},
|
|
"editor-para-ie": {
|
|
condition: {
|
|
name: "editor-para-ie",
|
|
trigger: "editor-para",
|
|
ua: "ie",
|
|
when: "instead"
|
|
},
|
|
requires: [
|
|
"editor-para-base"
|
|
]
|
|
},
|
|
"editor-selection": {
|
|
requires: [
|
|
"node"
|
|
]
|
|
},
|
|
"editor-tab": {
|
|
requires: [
|
|
"editor-base"
|
|
]
|
|
},
|
|
escape: {
|
|
requires: [
|
|
"yui-base"
|
|
]
|
|
},
|
|
event: {
|
|
after: [
|
|
"node-base"
|
|
],
|
|
use: [
|
|
"event-base",
|
|
"event-delegate",
|
|
"event-synthetic",
|
|
"event-mousewheel",
|
|
"event-mouseenter",
|
|
"event-key",
|
|
"event-focus",
|
|
"event-resize",
|
|
"event-hover",
|
|
"event-outside",
|
|
"event-touch",
|
|
"event-move",
|
|
"event-flick",
|
|
"event-valuechange",
|
|
"event-tap"
|
|
]
|
|
},
|
|
"event-base": {
|
|
after: [
|
|
"node-base"
|
|
],
|
|
requires: [
|
|
"event-custom-base"
|
|
]
|
|
},
|
|
"event-base-ie": {
|
|
after: [
|
|
"event-base"
|
|
],
|
|
condition: {
|
|
name: "event-base-ie",
|
|
test: function(Y) {
|
|
var imp = Y.config.doc && Y.config.doc.implementation;
|
|
return imp && !imp.hasFeature('Events', '2.0');
|
|
},
|
|
trigger: "node-base"
|
|
},
|
|
requires: [
|
|
"node-base"
|
|
]
|
|
},
|
|
"event-contextmenu": {
|
|
requires: [
|
|
"event-synthetic",
|
|
"dom-screen"
|
|
]
|
|
},
|
|
"event-custom": {
|
|
use: [
|
|
"event-custom-base",
|
|
"event-custom-complex"
|
|
]
|
|
},
|
|
"event-custom-base": {
|
|
requires: [
|
|
"oop"
|
|
]
|
|
},
|
|
"event-custom-complex": {
|
|
requires: [
|
|
"event-custom-base"
|
|
]
|
|
},
|
|
"event-delegate": {
|
|
requires: [
|
|
"node-base"
|
|
]
|
|
},
|
|
"event-flick": {
|
|
requires: [
|
|
"node-base",
|
|
"event-touch",
|
|
"event-synthetic"
|
|
]
|
|
},
|
|
"event-focus": {
|
|
requires: [
|
|
"event-synthetic"
|
|
]
|
|
},
|
|
"event-gestures": {
|
|
use: [
|
|
"event-flick",
|
|
"event-move"
|
|
]
|
|
},
|
|
"event-hover": {
|
|
requires: [
|
|
"event-mouseenter"
|
|
]
|
|
},
|
|
"event-key": {
|
|
requires: [
|
|
"event-synthetic"
|
|
]
|
|
},
|
|
"event-mouseenter": {
|
|
requires: [
|
|
"event-synthetic"
|
|
]
|
|
},
|
|
"event-mousewheel": {
|
|
requires: [
|
|
"node-base"
|
|
]
|
|
},
|
|
"event-move": {
|
|
requires: [
|
|
"node-base",
|
|
"event-touch",
|
|
"event-synthetic"
|
|
]
|
|
},
|
|
"event-outside": {
|
|
requires: [
|
|
"event-synthetic"
|
|
]
|
|
},
|
|
"event-resize": {
|
|
requires: [
|
|
"node-base",
|
|
"event-synthetic"
|
|
]
|
|
},
|
|
"event-simulate": {
|
|
requires: [
|
|
"event-base"
|
|
]
|
|
},
|
|
"event-synthetic": {
|
|
requires: [
|
|
"node-base",
|
|
"event-custom-complex"
|
|
]
|
|
},
|
|
"event-tap": {
|
|
requires: [
|
|
"node-base",
|
|
"event-base",
|
|
"event-touch",
|
|
"event-synthetic"
|
|
]
|
|
},
|
|
"event-touch": {
|
|
requires: [
|
|
"node-base"
|
|
]
|
|
},
|
|
"event-valuechange": {
|
|
requires: [
|
|
"event-focus",
|
|
"event-synthetic"
|
|
]
|
|
},
|
|
"exec-command": {
|
|
requires: [
|
|
"frame"
|
|
]
|
|
},
|
|
features: {
|
|
requires: [
|
|
"yui-base"
|
|
]
|
|
},
|
|
file: {
|
|
requires: [
|
|
"file-flash",
|
|
"file-html5"
|
|
]
|
|
},
|
|
"file-flash": {
|
|
requires: [
|
|
"base"
|
|
]
|
|
},
|
|
"file-html5": {
|
|
requires: [
|
|
"base"
|
|
]
|
|
},
|
|
frame: {
|
|
requires: [
|
|
"base",
|
|
"node",
|
|
"selector-css3",
|
|
"yui-throttle"
|
|
]
|
|
},
|
|
"gesture-simulate": {
|
|
requires: [
|
|
"async-queue",
|
|
"event-simulate",
|
|
"node-screen"
|
|
]
|
|
},
|
|
get: {
|
|
requires: [
|
|
"yui-base"
|
|
]
|
|
},
|
|
graphics: {
|
|
requires: [
|
|
"node",
|
|
"event-custom",
|
|
"pluginhost",
|
|
"matrix",
|
|
"classnamemanager"
|
|
]
|
|
},
|
|
"graphics-canvas": {
|
|
condition: {
|
|
name: "graphics-canvas",
|
|
test: function(Y) {
|
|
var DOCUMENT = Y.config.doc, useCanvas = Y.config.defaultGraphicEngine && "canvas" == Y.config.defaultGraphicEngine, canvas = DOCUMENT && DOCUMENT.createElement("canvas");
|
|
return (!(DOCUMENT && DOCUMENT.implementation.hasFeature("http://www.w3.org/TR/SVG11/feature#BasicStructure", "1.1")) || useCanvas) && canvas && canvas.getContext && canvas.getContext("2d");
|
|
},
|
|
trigger: "graphics"
|
|
},
|
|
requires: [
|
|
"graphics"
|
|
]
|
|
},
|
|
"graphics-canvas-default": {
|
|
condition: {
|
|
name: "graphics-canvas-default",
|
|
test: function(Y) {
|
|
var DOCUMENT = Y.config.doc, useCanvas = Y.config.defaultGraphicEngine && "canvas" == Y.config.defaultGraphicEngine, canvas = DOCUMENT && DOCUMENT.createElement("canvas");
|
|
return (!(DOCUMENT && DOCUMENT.implementation.hasFeature("http://www.w3.org/TR/SVG11/feature#BasicStructure", "1.1")) || useCanvas) && canvas && canvas.getContext && canvas.getContext("2d");
|
|
},
|
|
trigger: "graphics"
|
|
}
|
|
},
|
|
"graphics-group": {
|
|
requires: [
|
|
"graphics"
|
|
]
|
|
},
|
|
"graphics-svg": {
|
|
condition: {
|
|
name: "graphics-svg",
|
|
test: function(Y) {
|
|
var DOCUMENT = Y.config.doc, useSVG = !Y.config.defaultGraphicEngine || "canvas" != Y.config.defaultGraphicEngine, canvas = DOCUMENT && DOCUMENT.createElement("canvas"), svg = DOCUMENT && DOCUMENT.implementation.hasFeature("http://www.w3.org/TR/SVG11/feature#BasicStructure", "1.1");
|
|
return svg && (useSVG || !canvas);
|
|
},
|
|
trigger: "graphics"
|
|
},
|
|
requires: [
|
|
"graphics"
|
|
]
|
|
},
|
|
"graphics-svg-default": {
|
|
condition: {
|
|
name: "graphics-svg-default",
|
|
test: function(Y) {
|
|
var DOCUMENT = Y.config.doc, useSVG = !Y.config.defaultGraphicEngine || "canvas" != Y.config.defaultGraphicEngine, canvas = DOCUMENT && DOCUMENT.createElement("canvas"), svg = DOCUMENT && DOCUMENT.implementation.hasFeature("http://www.w3.org/TR/SVG11/feature#BasicStructure", "1.1");
|
|
return svg && (useSVG || !canvas);
|
|
},
|
|
trigger: "graphics"
|
|
}
|
|
},
|
|
"graphics-vml": {
|
|
condition: {
|
|
name: "graphics-vml",
|
|
test: function(Y) {
|
|
var DOCUMENT = Y.config.doc, canvas = DOCUMENT && DOCUMENT.createElement("canvas");
|
|
return DOCUMENT && !DOCUMENT.implementation.hasFeature("http://www.w3.org/TR/SVG11/feature#BasicStructure", "1.1") && (!canvas || !canvas.getContext || !canvas.getContext("2d"));
|
|
},
|
|
trigger: "graphics"
|
|
},
|
|
requires: [
|
|
"graphics"
|
|
]
|
|
},
|
|
"graphics-vml-default": {
|
|
condition: {
|
|
name: "graphics-vml-default",
|
|
test: function(Y) {
|
|
var DOCUMENT = Y.config.doc, canvas = DOCUMENT && DOCUMENT.createElement("canvas");
|
|
return DOCUMENT && !DOCUMENT.implementation.hasFeature("http://www.w3.org/TR/SVG11/feature#BasicStructure", "1.1") && (!canvas || !canvas.getContext || !canvas.getContext("2d"));
|
|
},
|
|
trigger: "graphics"
|
|
}
|
|
},
|
|
handlebars: {
|
|
use: [
|
|
"handlebars-compiler"
|
|
]
|
|
},
|
|
"handlebars-base": {
|
|
requires: []
|
|
},
|
|
"handlebars-compiler": {
|
|
requires: [
|
|
"handlebars-base"
|
|
]
|
|
},
|
|
highlight: {
|
|
use: [
|
|
"highlight-base",
|
|
"highlight-accentfold"
|
|
]
|
|
},
|
|
"highlight-accentfold": {
|
|
requires: [
|
|
"highlight-base",
|
|
"text-accentfold"
|
|
]
|
|
},
|
|
"highlight-base": {
|
|
requires: [
|
|
"array-extras",
|
|
"classnamemanager",
|
|
"escape",
|
|
"text-wordbreak"
|
|
]
|
|
},
|
|
history: {
|
|
use: [
|
|
"history-base",
|
|
"history-hash",
|
|
"history-hash-ie",
|
|
"history-html5"
|
|
]
|
|
},
|
|
"history-base": {
|
|
requires: [
|
|
"event-custom-complex"
|
|
]
|
|
},
|
|
"history-hash": {
|
|
after: [
|
|
"history-html5"
|
|
],
|
|
requires: [
|
|
"event-synthetic",
|
|
"history-base",
|
|
"yui-later"
|
|
]
|
|
},
|
|
"history-hash-ie": {
|
|
condition: {
|
|
name: "history-hash-ie",
|
|
test: function(Y) {
|
|
var docMode = Y.config.doc && Y.config.doc.documentMode;
|
|
return Y.UA.ie && (!('onhashchange' in Y.config.win) || !docMode || docMode < 8);
|
|
},
|
|
trigger: "history-hash"
|
|
},
|
|
requires: [
|
|
"history-hash",
|
|
"node-base"
|
|
]
|
|
},
|
|
"history-html5": {
|
|
optional: [
|
|
"json"
|
|
],
|
|
requires: [
|
|
"event-base",
|
|
"history-base",
|
|
"node-base"
|
|
]
|
|
},
|
|
imageloader: {
|
|
requires: [
|
|
"base-base",
|
|
"node-style",
|
|
"node-screen"
|
|
]
|
|
},
|
|
intl: {
|
|
requires: [
|
|
"intl-base",
|
|
"event-custom"
|
|
]
|
|
},
|
|
"intl-base": {
|
|
requires: [
|
|
"yui-base"
|
|
]
|
|
},
|
|
io: {
|
|
use: [
|
|
"io-base",
|
|
"io-xdr",
|
|
"io-form",
|
|
"io-upload-iframe",
|
|
"io-queue"
|
|
]
|
|
},
|
|
"io-base": {
|
|
requires: [
|
|
"event-custom-base",
|
|
"querystring-stringify-simple"
|
|
]
|
|
},
|
|
"io-form": {
|
|
requires: [
|
|
"io-base",
|
|
"node-base"
|
|
]
|
|
},
|
|
"io-nodejs": {
|
|
condition: {
|
|
name: "io-nodejs",
|
|
trigger: "io-base",
|
|
ua: "nodejs"
|
|
},
|
|
requires: [
|
|
"io-base"
|
|
]
|
|
},
|
|
"io-queue": {
|
|
requires: [
|
|
"io-base",
|
|
"queue-promote"
|
|
]
|
|
},
|
|
"io-upload-iframe": {
|
|
requires: [
|
|
"io-base",
|
|
"node-base"
|
|
]
|
|
},
|
|
"io-xdr": {
|
|
requires: [
|
|
"io-base",
|
|
"datatype-xml-parse"
|
|
]
|
|
},
|
|
json: {
|
|
use: [
|
|
"json-parse",
|
|
"json-stringify"
|
|
]
|
|
},
|
|
"json-parse": {
|
|
requires: [
|
|
"yui-base"
|
|
]
|
|
},
|
|
"json-parse-shim": {
|
|
condition: {
|
|
name: "json-parse-shim",
|
|
test: function(Y) {
|
|
var _JSON = Y.config.global.JSON, Native = '[object JSON]' === Object.prototype.toString.call(_JSON) && _JSON, nativeSupport = !1 !== Y.config.useNativeJSONParse && !!Native;
|
|
if (nativeSupport) try {
|
|
nativeSupport = Native.parse('{"ok":false}', function(k, v) {
|
|
return "ok" === k || v;
|
|
}).ok;
|
|
} catch (e) {
|
|
nativeSupport = !1;
|
|
}
|
|
return !nativeSupport;
|
|
},
|
|
trigger: "json-parse"
|
|
},
|
|
requires: [
|
|
"json-parse"
|
|
]
|
|
},
|
|
"json-stringify": {
|
|
requires: [
|
|
"yui-base"
|
|
]
|
|
},
|
|
"json-stringify-shim": {
|
|
condition: {
|
|
name: "json-stringify-shim",
|
|
test: function(Y) {
|
|
var _JSON = Y.config.global.JSON, Native = '[object JSON]' === Object.prototype.toString.call(_JSON) && _JSON, nativeSupport = !1 !== Y.config.useNativeJSONStringify && !!Native;
|
|
if (nativeSupport) try {
|
|
nativeSupport = '0' === Native.stringify(0);
|
|
} catch (e) {
|
|
nativeSupport = !1;
|
|
}
|
|
return !nativeSupport;
|
|
},
|
|
trigger: "json-stringify"
|
|
},
|
|
requires: [
|
|
"json-stringify"
|
|
]
|
|
},
|
|
jsonp: {
|
|
requires: [
|
|
"get",
|
|
"oop"
|
|
]
|
|
},
|
|
"jsonp-url": {
|
|
requires: [
|
|
"jsonp"
|
|
]
|
|
},
|
|
"lazy-model-list": {
|
|
requires: [
|
|
"model-list"
|
|
]
|
|
},
|
|
loader: {
|
|
use: [
|
|
"loader-base",
|
|
"loader-rollup",
|
|
"loader-yui3"
|
|
]
|
|
},
|
|
"loader-base": {
|
|
requires: [
|
|
"get",
|
|
"features"
|
|
]
|
|
},
|
|
"loader-rollup": {
|
|
requires: [
|
|
"loader-base"
|
|
]
|
|
},
|
|
"loader-yui3": {
|
|
requires: [
|
|
"loader-base"
|
|
]
|
|
},
|
|
matrix: {
|
|
requires: [
|
|
"yui-base"
|
|
]
|
|
},
|
|
model: {
|
|
requires: [
|
|
"base-build",
|
|
"escape",
|
|
"json-parse"
|
|
]
|
|
},
|
|
"model-list": {
|
|
requires: [
|
|
"array-extras",
|
|
"array-invoke",
|
|
"arraylist",
|
|
"base-build",
|
|
"escape",
|
|
"json-parse",
|
|
"model"
|
|
]
|
|
},
|
|
"model-sync-rest": {
|
|
requires: [
|
|
"model",
|
|
"io-base",
|
|
"json-stringify"
|
|
]
|
|
},
|
|
node: {
|
|
use: [
|
|
"node-base",
|
|
"node-event-delegate",
|
|
"node-pluginhost",
|
|
"node-screen",
|
|
"node-style"
|
|
]
|
|
},
|
|
"node-base": {
|
|
requires: [
|
|
"event-base",
|
|
"node-core",
|
|
"dom-base",
|
|
"dom-style"
|
|
]
|
|
},
|
|
"node-core": {
|
|
requires: [
|
|
"dom-core",
|
|
"selector"
|
|
]
|
|
},
|
|
"node-deprecated": {
|
|
requires: [
|
|
"node-base"
|
|
]
|
|
},
|
|
"node-event-delegate": {
|
|
requires: [
|
|
"node-base",
|
|
"event-delegate"
|
|
]
|
|
},
|
|
"node-event-html5": {
|
|
requires: [
|
|
"node-base"
|
|
]
|
|
},
|
|
"node-event-simulate": {
|
|
requires: [
|
|
"node-base",
|
|
"event-simulate",
|
|
"gesture-simulate"
|
|
]
|
|
},
|
|
"node-flick": {
|
|
requires: [
|
|
"classnamemanager",
|
|
"transition",
|
|
"event-flick",
|
|
"plugin"
|
|
],
|
|
skinnable: !0
|
|
},
|
|
"node-focusmanager": {
|
|
requires: [
|
|
"attribute",
|
|
"node",
|
|
"plugin",
|
|
"node-event-simulate",
|
|
"event-key",
|
|
"event-focus"
|
|
]
|
|
},
|
|
"node-load": {
|
|
requires: [
|
|
"node-base",
|
|
"io-base"
|
|
]
|
|
},
|
|
"node-menunav": {
|
|
requires: [
|
|
"node",
|
|
"classnamemanager",
|
|
"plugin",
|
|
"node-focusmanager"
|
|
],
|
|
skinnable: !0
|
|
},
|
|
"node-pluginhost": {
|
|
requires: [
|
|
"node-base",
|
|
"pluginhost"
|
|
]
|
|
},
|
|
"node-screen": {
|
|
requires: [
|
|
"dom-screen",
|
|
"node-base"
|
|
]
|
|
},
|
|
"node-scroll-info": {
|
|
requires: [
|
|
"array-extras",
|
|
"base-build",
|
|
"event-resize",
|
|
"node-pluginhost",
|
|
"plugin",
|
|
"selector"
|
|
]
|
|
},
|
|
"node-style": {
|
|
requires: [
|
|
"dom-style",
|
|
"node-base"
|
|
]
|
|
},
|
|
oop: {
|
|
requires: [
|
|
"yui-base"
|
|
]
|
|
},
|
|
overlay: {
|
|
requires: [
|
|
"widget",
|
|
"widget-stdmod",
|
|
"widget-position",
|
|
"widget-position-align",
|
|
"widget-stack",
|
|
"widget-position-constrain"
|
|
],
|
|
skinnable: !0
|
|
},
|
|
paginator: {
|
|
requires: [
|
|
"paginator-core"
|
|
]
|
|
},
|
|
"paginator-core": {
|
|
requires: [
|
|
"base"
|
|
]
|
|
},
|
|
"paginator-url": {
|
|
requires: [
|
|
"paginator"
|
|
]
|
|
},
|
|
panel: {
|
|
requires: [
|
|
"widget",
|
|
"widget-autohide",
|
|
"widget-buttons",
|
|
"widget-modality",
|
|
"widget-position",
|
|
"widget-position-align",
|
|
"widget-position-constrain",
|
|
"widget-stack",
|
|
"widget-stdmod"
|
|
],
|
|
skinnable: !0
|
|
},
|
|
parallel: {
|
|
requires: [
|
|
"yui-base"
|
|
]
|
|
},
|
|
pjax: {
|
|
requires: [
|
|
"pjax-base",
|
|
"pjax-content"
|
|
]
|
|
},
|
|
"pjax-base": {
|
|
requires: [
|
|
"classnamemanager",
|
|
"node-event-delegate",
|
|
"router"
|
|
]
|
|
},
|
|
"pjax-content": {
|
|
requires: [
|
|
"io-base",
|
|
"node-base",
|
|
"router"
|
|
]
|
|
},
|
|
"pjax-plugin": {
|
|
requires: [
|
|
"node-pluginhost",
|
|
"pjax",
|
|
"plugin"
|
|
]
|
|
},
|
|
plugin: {
|
|
requires: [
|
|
"base-base"
|
|
]
|
|
},
|
|
pluginhost: {
|
|
use: [
|
|
"pluginhost-base",
|
|
"pluginhost-config"
|
|
]
|
|
},
|
|
"pluginhost-base": {
|
|
requires: [
|
|
"yui-base"
|
|
]
|
|
},
|
|
"pluginhost-config": {
|
|
requires: [
|
|
"pluginhost-base"
|
|
]
|
|
},
|
|
promise: {
|
|
requires: [
|
|
"timers"
|
|
]
|
|
},
|
|
querystring: {
|
|
use: [
|
|
"querystring-parse",
|
|
"querystring-stringify"
|
|
]
|
|
},
|
|
"querystring-parse": {
|
|
requires: [
|
|
"yui-base",
|
|
"array-extras"
|
|
]
|
|
},
|
|
"querystring-parse-simple": {
|
|
requires: [
|
|
"yui-base"
|
|
]
|
|
},
|
|
"querystring-stringify": {
|
|
requires: [
|
|
"yui-base"
|
|
]
|
|
},
|
|
"querystring-stringify-simple": {
|
|
requires: [
|
|
"yui-base"
|
|
]
|
|
},
|
|
"queue-promote": {
|
|
requires: [
|
|
"yui-base"
|
|
]
|
|
},
|
|
"range-slider": {
|
|
requires: [
|
|
"slider-base",
|
|
"slider-value-range",
|
|
"clickable-rail"
|
|
]
|
|
},
|
|
recordset: {
|
|
use: [
|
|
"recordset-base",
|
|
"recordset-sort",
|
|
"recordset-filter",
|
|
"recordset-indexer"
|
|
]
|
|
},
|
|
"recordset-base": {
|
|
requires: [
|
|
"base",
|
|
"arraylist"
|
|
]
|
|
},
|
|
"recordset-filter": {
|
|
requires: [
|
|
"recordset-base",
|
|
"array-extras",
|
|
"plugin"
|
|
]
|
|
},
|
|
"recordset-indexer": {
|
|
requires: [
|
|
"recordset-base",
|
|
"plugin"
|
|
]
|
|
},
|
|
"recordset-sort": {
|
|
requires: [
|
|
"arraysort",
|
|
"recordset-base",
|
|
"plugin"
|
|
]
|
|
},
|
|
resize: {
|
|
use: [
|
|
"resize-base",
|
|
"resize-proxy",
|
|
"resize-constrain"
|
|
]
|
|
},
|
|
"resize-base": {
|
|
requires: [
|
|
"base",
|
|
"widget",
|
|
"event",
|
|
"oop",
|
|
"dd-drag",
|
|
"dd-delegate",
|
|
"dd-drop"
|
|
],
|
|
skinnable: !0
|
|
},
|
|
"resize-constrain": {
|
|
requires: [
|
|
"plugin",
|
|
"resize-base"
|
|
]
|
|
},
|
|
"resize-plugin": {
|
|
optional: [
|
|
"resize-constrain"
|
|
],
|
|
requires: [
|
|
"resize-base",
|
|
"plugin"
|
|
]
|
|
},
|
|
"resize-proxy": {
|
|
requires: [
|
|
"plugin",
|
|
"resize-base"
|
|
]
|
|
},
|
|
router: {
|
|
optional: [
|
|
"querystring-parse"
|
|
],
|
|
requires: [
|
|
"array-extras",
|
|
"base-build",
|
|
"history"
|
|
]
|
|
},
|
|
scrollview: {
|
|
requires: [
|
|
"scrollview-base",
|
|
"scrollview-scrollbars"
|
|
]
|
|
},
|
|
"scrollview-base": {
|
|
requires: [
|
|
"widget",
|
|
"event-gestures",
|
|
"event-mousewheel",
|
|
"transition"
|
|
],
|
|
skinnable: !0
|
|
},
|
|
"scrollview-base-ie": {
|
|
condition: {
|
|
name: "scrollview-base-ie",
|
|
trigger: "scrollview-base",
|
|
ua: "ie"
|
|
},
|
|
requires: [
|
|
"scrollview-base"
|
|
]
|
|
},
|
|
"scrollview-list": {
|
|
requires: [
|
|
"plugin",
|
|
"classnamemanager"
|
|
],
|
|
skinnable: !0
|
|
},
|
|
"scrollview-paginator": {
|
|
requires: [
|
|
"plugin",
|
|
"classnamemanager"
|
|
]
|
|
},
|
|
"scrollview-scrollbars": {
|
|
requires: [
|
|
"classnamemanager",
|
|
"transition",
|
|
"plugin"
|
|
],
|
|
skinnable: !0
|
|
},
|
|
selector: {
|
|
requires: [
|
|
"selector-native"
|
|
]
|
|
},
|
|
"selector-css2": {
|
|
condition: {
|
|
name: "selector-css2",
|
|
test: function(Y) {
|
|
var DOCUMENT = Y.config.doc;
|
|
return DOCUMENT && !('querySelectorAll' in DOCUMENT);
|
|
},
|
|
trigger: "selector"
|
|
},
|
|
requires: [
|
|
"selector-native"
|
|
]
|
|
},
|
|
"selector-css3": {
|
|
requires: [
|
|
"selector-native",
|
|
"selector-css2"
|
|
]
|
|
},
|
|
"selector-native": {
|
|
requires: [
|
|
"dom-base"
|
|
]
|
|
},
|
|
"series-area": {
|
|
requires: [
|
|
"series-cartesian",
|
|
"series-fill-util"
|
|
]
|
|
},
|
|
"series-area-stacked": {
|
|
requires: [
|
|
"series-stacked",
|
|
"series-area"
|
|
]
|
|
},
|
|
"series-areaspline": {
|
|
requires: [
|
|
"series-area",
|
|
"series-curve-util"
|
|
]
|
|
},
|
|
"series-areaspline-stacked": {
|
|
requires: [
|
|
"series-stacked",
|
|
"series-areaspline"
|
|
]
|
|
},
|
|
"series-bar": {
|
|
requires: [
|
|
"series-marker",
|
|
"series-histogram-base"
|
|
]
|
|
},
|
|
"series-bar-stacked": {
|
|
requires: [
|
|
"series-stacked",
|
|
"series-bar"
|
|
]
|
|
},
|
|
"series-base": {
|
|
requires: [
|
|
"graphics",
|
|
"axis-base"
|
|
]
|
|
},
|
|
"series-candlestick": {
|
|
requires: [
|
|
"series-range"
|
|
]
|
|
},
|
|
"series-cartesian": {
|
|
requires: [
|
|
"series-base"
|
|
]
|
|
},
|
|
"series-column": {
|
|
requires: [
|
|
"series-marker",
|
|
"series-histogram-base"
|
|
]
|
|
},
|
|
"series-column-stacked": {
|
|
requires: [
|
|
"series-stacked",
|
|
"series-column"
|
|
]
|
|
},
|
|
"series-combo": {
|
|
requires: [
|
|
"series-cartesian",
|
|
"series-line-util",
|
|
"series-plot-util",
|
|
"series-fill-util"
|
|
]
|
|
},
|
|
"series-combo-stacked": {
|
|
requires: [
|
|
"series-stacked",
|
|
"series-combo"
|
|
]
|
|
},
|
|
"series-combospline": {
|
|
requires: [
|
|
"series-combo",
|
|
"series-curve-util"
|
|
]
|
|
},
|
|
"series-combospline-stacked": {
|
|
requires: [
|
|
"series-combo-stacked",
|
|
"series-curve-util"
|
|
]
|
|
},
|
|
"series-curve-util": {},
|
|
"series-fill-util": {},
|
|
"series-histogram-base": {
|
|
requires: [
|
|
"series-cartesian",
|
|
"series-plot-util"
|
|
]
|
|
},
|
|
"series-line": {
|
|
requires: [
|
|
"series-cartesian",
|
|
"series-line-util"
|
|
]
|
|
},
|
|
"series-line-stacked": {
|
|
requires: [
|
|
"series-stacked",
|
|
"series-line"
|
|
]
|
|
},
|
|
"series-line-util": {},
|
|
"series-marker": {
|
|
requires: [
|
|
"series-cartesian",
|
|
"series-plot-util"
|
|
]
|
|
},
|
|
"series-marker-stacked": {
|
|
requires: [
|
|
"series-stacked",
|
|
"series-marker"
|
|
]
|
|
},
|
|
"series-ohlc": {
|
|
requires: [
|
|
"series-range"
|
|
]
|
|
},
|
|
"series-pie": {
|
|
requires: [
|
|
"series-base",
|
|
"series-plot-util"
|
|
]
|
|
},
|
|
"series-plot-util": {},
|
|
"series-range": {
|
|
requires: [
|
|
"series-cartesian"
|
|
]
|
|
},
|
|
"series-spline": {
|
|
requires: [
|
|
"series-line",
|
|
"series-curve-util"
|
|
]
|
|
},
|
|
"series-spline-stacked": {
|
|
requires: [
|
|
"series-stacked",
|
|
"series-spline"
|
|
]
|
|
},
|
|
"series-stacked": {
|
|
requires: [
|
|
"axis-stacked"
|
|
]
|
|
},
|
|
"shim-plugin": {
|
|
requires: [
|
|
"node-style",
|
|
"node-pluginhost"
|
|
]
|
|
},
|
|
slider: {
|
|
use: [
|
|
"slider-base",
|
|
"slider-value-range",
|
|
"clickable-rail",
|
|
"range-slider"
|
|
]
|
|
},
|
|
"slider-base": {
|
|
requires: [
|
|
"widget",
|
|
"dd-constrain",
|
|
"event-key"
|
|
],
|
|
skinnable: !0
|
|
},
|
|
"slider-value-range": {
|
|
requires: [
|
|
"slider-base"
|
|
]
|
|
},
|
|
sortable: {
|
|
requires: [
|
|
"dd-delegate",
|
|
"dd-drop-plugin",
|
|
"dd-proxy"
|
|
]
|
|
},
|
|
"sortable-scroll": {
|
|
requires: [
|
|
"dd-scroll",
|
|
"sortable"
|
|
]
|
|
},
|
|
stylesheet: {
|
|
requires: [
|
|
"yui-base"
|
|
]
|
|
},
|
|
substitute: {
|
|
optional: [
|
|
"dump"
|
|
],
|
|
requires: [
|
|
"yui-base"
|
|
]
|
|
},
|
|
swf: {
|
|
requires: [
|
|
"event-custom",
|
|
"node",
|
|
"swfdetect",
|
|
"escape"
|
|
]
|
|
},
|
|
swfdetect: {
|
|
requires: [
|
|
"yui-base"
|
|
]
|
|
},
|
|
tabview: {
|
|
requires: [
|
|
"widget",
|
|
"widget-parent",
|
|
"widget-child",
|
|
"tabview-base",
|
|
"node-pluginhost",
|
|
"node-focusmanager"
|
|
],
|
|
skinnable: !0
|
|
},
|
|
"tabview-base": {
|
|
requires: [
|
|
"node-event-delegate",
|
|
"classnamemanager"
|
|
]
|
|
},
|
|
"tabview-plugin": {
|
|
requires: [
|
|
"tabview-base"
|
|
]
|
|
},
|
|
template: {
|
|
use: [
|
|
"template-base",
|
|
"template-micro"
|
|
]
|
|
},
|
|
"template-base": {
|
|
requires: [
|
|
"yui-base"
|
|
]
|
|
},
|
|
"template-micro": {
|
|
requires: [
|
|
"escape"
|
|
]
|
|
},
|
|
test: {
|
|
requires: [
|
|
"event-simulate",
|
|
"event-custom",
|
|
"json-stringify"
|
|
]
|
|
},
|
|
"test-console": {
|
|
requires: [
|
|
"console-filters",
|
|
"test",
|
|
"array-extras"
|
|
],
|
|
skinnable: !0
|
|
},
|
|
text: {
|
|
use: [
|
|
"text-accentfold",
|
|
"text-wordbreak"
|
|
]
|
|
},
|
|
"text-accentfold": {
|
|
requires: [
|
|
"array-extras",
|
|
"text-data-accentfold"
|
|
]
|
|
},
|
|
"text-data-accentfold": {
|
|
requires: [
|
|
"yui-base"
|
|
]
|
|
},
|
|
"text-data-wordbreak": {
|
|
requires: [
|
|
"yui-base"
|
|
]
|
|
},
|
|
"text-wordbreak": {
|
|
requires: [
|
|
"array-extras",
|
|
"text-data-wordbreak"
|
|
]
|
|
},
|
|
timers: {
|
|
requires: [
|
|
"yui-base"
|
|
]
|
|
},
|
|
transition: {
|
|
requires: [
|
|
"node-style"
|
|
]
|
|
},
|
|
"transition-timer": {
|
|
condition: {
|
|
name: "transition-timer",
|
|
test: function(Y) {
|
|
var DOCUMENT = Y.config.doc, node = DOCUMENT ? DOCUMENT.documentElement : null, ret = !0;
|
|
return node && node.style && (ret = !('MozTransition' in node.style || 'WebkitTransition' in node.style || 'transition' in node.style)), ret;
|
|
},
|
|
trigger: "transition"
|
|
},
|
|
requires: [
|
|
"transition"
|
|
]
|
|
},
|
|
tree: {
|
|
requires: [
|
|
"base-build",
|
|
"tree-node"
|
|
]
|
|
},
|
|
"tree-labelable": {
|
|
requires: [
|
|
"tree"
|
|
]
|
|
},
|
|
"tree-lazy": {
|
|
requires: [
|
|
"base-pluginhost",
|
|
"plugin",
|
|
"tree"
|
|
]
|
|
},
|
|
"tree-node": {},
|
|
"tree-openable": {
|
|
requires: [
|
|
"tree"
|
|
]
|
|
},
|
|
"tree-selectable": {
|
|
requires: [
|
|
"tree"
|
|
]
|
|
},
|
|
"tree-sortable": {
|
|
requires: [
|
|
"tree"
|
|
]
|
|
},
|
|
uploader: {
|
|
requires: [
|
|
"uploader-html5",
|
|
"uploader-flash"
|
|
]
|
|
},
|
|
"uploader-flash": {
|
|
requires: [
|
|
"swf",
|
|
"widget",
|
|
"base",
|
|
"cssbutton",
|
|
"node",
|
|
"event-custom",
|
|
"file-flash",
|
|
"uploader-queue"
|
|
]
|
|
},
|
|
"uploader-html5": {
|
|
requires: [
|
|
"widget",
|
|
"node-event-simulate",
|
|
"file-html5",
|
|
"uploader-queue"
|
|
]
|
|
},
|
|
"uploader-queue": {
|
|
requires: [
|
|
"base"
|
|
]
|
|
},
|
|
view: {
|
|
requires: [
|
|
"base-build",
|
|
"node-event-delegate"
|
|
]
|
|
},
|
|
"view-node-map": {
|
|
requires: [
|
|
"view"
|
|
]
|
|
},
|
|
widget: {
|
|
use: [
|
|
"widget-base",
|
|
"widget-htmlparser",
|
|
"widget-skin",
|
|
"widget-uievents"
|
|
]
|
|
},
|
|
"widget-anim": {
|
|
requires: [
|
|
"anim-base",
|
|
"plugin",
|
|
"widget"
|
|
]
|
|
},
|
|
"widget-autohide": {
|
|
requires: [
|
|
"base-build",
|
|
"event-key",
|
|
"event-outside",
|
|
"widget"
|
|
]
|
|
},
|
|
"widget-base": {
|
|
requires: [
|
|
"attribute",
|
|
"base-base",
|
|
"base-pluginhost",
|
|
"classnamemanager",
|
|
"event-focus",
|
|
"node-base",
|
|
"node-style"
|
|
],
|
|
skinnable: !0
|
|
},
|
|
"widget-base-ie": {
|
|
condition: {
|
|
name: "widget-base-ie",
|
|
trigger: "widget-base",
|
|
ua: "ie"
|
|
},
|
|
requires: [
|
|
"widget-base"
|
|
]
|
|
},
|
|
"widget-buttons": {
|
|
requires: [
|
|
"button-plugin",
|
|
"cssbutton",
|
|
"widget-stdmod"
|
|
]
|
|
},
|
|
"widget-child": {
|
|
requires: [
|
|
"base-build",
|
|
"widget"
|
|
]
|
|
},
|
|
"widget-htmlparser": {
|
|
requires: [
|
|
"widget-base"
|
|
]
|
|
},
|
|
"widget-locale": {
|
|
requires: [
|
|
"widget-base"
|
|
]
|
|
},
|
|
"widget-modality": {
|
|
requires: [
|
|
"base-build",
|
|
"event-outside",
|
|
"widget"
|
|
],
|
|
skinnable: !0
|
|
},
|
|
"widget-parent": {
|
|
requires: [
|
|
"arraylist",
|
|
"base-build",
|
|
"widget"
|
|
]
|
|
},
|
|
"widget-position": {
|
|
requires: [
|
|
"base-build",
|
|
"node-screen",
|
|
"widget"
|
|
]
|
|
},
|
|
"widget-position-align": {
|
|
requires: [
|
|
"widget-position"
|
|
]
|
|
},
|
|
"widget-position-constrain": {
|
|
requires: [
|
|
"widget-position"
|
|
]
|
|
},
|
|
"widget-skin": {
|
|
requires: [
|
|
"widget-base"
|
|
]
|
|
},
|
|
"widget-stack": {
|
|
requires: [
|
|
"base-build",
|
|
"widget"
|
|
],
|
|
skinnable: !0
|
|
},
|
|
"widget-stdmod": {
|
|
requires: [
|
|
"base-build",
|
|
"widget"
|
|
]
|
|
},
|
|
"widget-uievents": {
|
|
requires: [
|
|
"node-event-delegate",
|
|
"widget-base"
|
|
]
|
|
},
|
|
yql: {
|
|
requires: [
|
|
"oop"
|
|
]
|
|
},
|
|
"yql-jsonp": {
|
|
condition: {
|
|
name: "yql-jsonp",
|
|
test: function(Y) {
|
|
return !Y.UA.nodejs && !Y.UA.winjs;
|
|
},
|
|
trigger: "yql",
|
|
when: "after"
|
|
},
|
|
requires: [
|
|
"jsonp",
|
|
"jsonp-url"
|
|
]
|
|
},
|
|
"yql-nodejs": {
|
|
condition: {
|
|
name: "yql-nodejs",
|
|
trigger: "yql",
|
|
ua: "nodejs",
|
|
when: "after"
|
|
}
|
|
},
|
|
"yql-winjs": {
|
|
condition: {
|
|
name: "yql-winjs",
|
|
trigger: "yql",
|
|
ua: "winjs",
|
|
when: "after"
|
|
}
|
|
},
|
|
yui: {},
|
|
"yui-base": {},
|
|
"yui-later": {
|
|
requires: [
|
|
"yui-base"
|
|
]
|
|
},
|
|
"yui-log": {
|
|
requires: [
|
|
"yui-base"
|
|
]
|
|
},
|
|
"yui-throttle": {
|
|
requires: [
|
|
"yui-base"
|
|
]
|
|
}
|
|
}), YUI.Env[Y4.version].md5 = 'fd7c67956df50e445f40d1668dd1dc80';
|
|
}, '3.12.0', {
|
|
requires: [
|
|
"loader-base"
|
|
]
|
|
}), YUI.add('yui', function(Y, NAME) {}, '3.12.0', {
|
|
use: [
|
|
"yui-base",
|
|
"get",
|
|
"features",
|
|
"intl-base",
|
|
"yui-log",
|
|
"yui-later",
|
|
"loader-base",
|
|
"loader-rollup",
|
|
"loader-yui3"
|
|
]
|
|
});
|