mirror of
https://github.com/swc-project/swc.git
synced 2024-12-30 00:52:29 +03:00
ac1d4058f2
swc_ecma_utils: - `collect_decls`: Support paramters of arrow expressions. swc_ecma_minifier: - `analyzer`: Fix `has_property_mutation`.
4672 lines
170 KiB
JavaScript
4672 lines
170 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 G_ENV, 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] && (req = null, use = null, (m = mods[name]) ? (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 = "\t\n\v\f\r \xa0 \u2028\u2029 ", WHITESPACE_CLASS = "[\t-\r \xa0 - \u2028\u2029 ]+", 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, transaction = null, (pending = this._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 (req = {
|
||
attributes: {}
|
||
}, "string" == typeof (url = urls[i])) 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), o = o || Y.config.win || Y;
|
||
var cancelled = !1, method = o && 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/", CDN_BASE = Y.Env.base, COMBO_BASE = CDN_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, mod1, 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++)mod1 = self.coverage[i], self.moduleInfo[mod1] && self.moduleInfo[mod1].use ? mods = [].concat(mods, self.moduleInfo[mod1].use) : mods.push(mod1);
|
||
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 && (c++, 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"
|
||
]
|
||
});
|