/**
+ * The YUI module contains the components required for building the YUI seed file.
+ * This includes the script loading mechanism, a simple queue, and the core utilities for the library.
+ * @module yui
+ * @submodule yui-base
+ */
+
+(function() {
+
+ var _instances = {},
+ _startTime = new Date().getTime(),
+ p,
+ i,
+
+ add = function () {
+ if (window.addEventListener) {
+ return function(el, type, fn, capture) {
+ el.addEventListener(type, fn, (!!capture));
+ };
+ } else if (window.attachEvent) {
+ return function(el, type, fn) {
+ el.attachEvent("on" + type, fn);
+ };
+ } else {
+ return function(){};
+ }
+ }(),
+
+ remove = function() {
+ if (window.removeEventListener) {
+ return function (el, type, fn, capture) {
+ el.removeEventListener(type, fn, !!capture);
+ };
+ } else if (window.detachEvent) {
+ return function (el, type, fn) {
+ el.detachEvent("on" + type, fn);
+ };
+ } else {
+ return function(){};
+ }
+ }(),
+
+ globalListener = function() {
+ YUI.Env.windowLoaded = true;
+ YUI.Env.DOMReady = true;
+ remove(window, 'load', globalListener);
+ },
+
+// @TODO: this needs to be created at build time from module metadata
+
+ _APPLY_TO_WHITE_LIST = {
+ 'io.xdrReady': 1,
+ 'io.xdrResponse':1
+ },
+
+ SLICE = Array.prototype.slice;
+
+// reduce to one or the other
+if (typeof YUI === 'undefined' || !YUI) {
+
+ /**
+ * The YUI global namespace object. If YUI is already defined, the
+ * existing YUI object will not be overwritten so that defined
+ * namespaces are preserved.
+ *
+ * @class YUI
+ * @constructor
+ * @global
+ * @uses EventTarget
+ * @param o* Up to five optional configuration objects. This object is stored
+ * in YUI.config. See config for the list of supported properties.
+ */
+
+ /*global YUI*/
+ // Make a function, disallow direct instantiation
+ YUI = function(o1, o2, o3, o4, o5) {
+
+ var Y = this, a = arguments, i, l = a.length;
+
+ // Allow instantiation without the new operator
+ if (!(Y instanceof YUI)) {
+ return new YUI(o1, o2, o3, o4, o5);
+ } else {
+ // set up the core environment
+ Y._init();
+
+ for (i=0; i<l; i++) {
+ Y._config(a[i]);
+ }
+
+ // bind the specified additional modules for this instance
+ Y._setup();
+
+ return Y;
+ }
+ };
+}
+
+// The prototype contains the functions that are required to allow the external
+// modules to be registered and for the instance to be initialized.
+YUI.prototype = {
+
+ _config: function(o) {
+
+ o = o || {};
+
+ var c = this.config, i, j, m, mods;
+
+ mods = c.modules;
+ for (i in o) {
+ if (mods && i == 'modules') {
+ m = o[i];
+ for (j in m) {
+ if (m.hasOwnProperty(j)) {
+ mods[j] = m[j];
+ }
+ }
+ } else if (i == 'win') {
+ c[i] = o[i].contentWindow || o[i];
+ c.doc = c[i].document;
+ } else {
+ c[i] = o[i];
+ }
+ }
+ },
+
+ /**
+ * Initialize this YUI instance
+ * @private
+ */
+ _init: function() {
+
+ // find targeted window/frame
+ // @TODO create facades
+ var v = '@VERSION@', Y = this;
+
+ if (v.indexOf('@') > -1) {
+ v = 'test';
+ }
+
+ Y.version = v;
+
+ Y.Env = {
+ // @todo expand the new module metadata
+ mods: {},
+ cdn: 'http://yui.yahooapis.com/' + v + '/build/',
+ bootstrapped: false,
+ _idx: 0,
+ _used: {},
+ _attached: {},
+ _yidx: 0,
+ _uidx: 0,
+ _loaded: {}
+ };
+
+ Y.Env._loaded[v] = {};
+
+ if (YUI.Env) {
+ Y.Env._yidx = (++YUI.Env._yidx);
+ Y.Env._guidp = ('yui_' + v + '-' + Y.Env._yidx + '-' + _startTime).replace(/\./g, '_');
+ Y.id = Y.stamp(Y);
+ _instances[Y.id] = Y;
+ }
+
+ Y.constructor = YUI;
+
+ // configuration defaults
+ Y.config = {
+
+ win: window || {},
+ doc: document,
+ debug: true,
+ useBrowserConsole: true,
+ throwFail: true,
+ bootstrap: true,
+ fetchCSS: true,
+
+ base: function() {
+ var b, nodes, i, match;
+
+ // get from querystring
+ nodes = document.getElementsByTagName('script');
+
+ for (i=0; i<nodes.length; i=i+1) {
+ match = nodes[i].src.match(/^(.*)yui\/yui[\.\-].*js(\?.*)?$/);
+ b = match && match[1];
+ if (b) {
+ break;
+ }
+ }
+
+ // use CDN default
+ return b || Y.Env.cdn;
+
+ }(),
+
+ loaderPath: 'loader/loader-min.js'
+ };
+
+ },
+
+ /**
+ * Finishes the instance setup. Attaches whatever modules were defined
+ * when the yui modules was registered.
+ * @method _setup
+ * @private
+ */
+ _setup: function(o) {
+ this.use("yui-base");
+ },
+
+ /**
+ * Executes a method on a YUI instance with
+ * the specified id if the specified method is whitelisted.
+ * @method applyTo
+ * @param id {string} the YUI instance id
+ * @param method {string} the name of the method to exectute.
+ * Ex: 'Object.keys'
+ * @param args {Array} the arguments to apply to the method
+ * @return {object} the return value from the applied method or null
+ */
+ applyTo: function(id, method, args) {
+
+ if (!(method in _APPLY_TO_WHITE_LIST)) {
+ this.log(method + ': applyTo not allowed', 'warn', 'yui');
+ return null;
+ }
+
+ var instance = _instances[id], nest, m, i;
+
+ if (instance) {
+
+ nest = method.split('.');
+ m = instance;
+
+ for (i=0; i<nest.length; i=i+1) {
+
+ m = m[nest[i]];
+
+ if (!m) {
+ this.log('applyTo not found: ' + method, 'warn', 'yui');
+ }
+ }
+
+ return m.apply(instance, args);
+ }
+
+ return null;
+ },
+
+ /**
+ * Register a module
+ * @method add
+ * @param name {string} module name
+ * @param fn {Function} entry point into the module that
+ * is used to bind module to the YUI instance
+ * @param version {string} version string
+ * @param details optional config data:
+ * requires - features that should be present before loading
+ * optional - optional features that should be present if load optional defined
+ * use - features that should be attached automatically
+ * skinnable -
+ * rollup
+ * omit - features that should not be loaded if this module is present
+ * @return {YUI} the YUI instance
+ *
+ */
+ add: function(name, fn, version, details) {
+ // this.log('Adding a new component ' + name);
+ // @todo expand this to include version mapping
+ // @todo may want to restore the build property
+ // @todo fire moduleAvailable event
+
+ YUI.Env.mods[name] = {
+ name: name,
+ fn: fn,
+ version: version,
+ details: details || {}
+ };
+
+ return this; // chain support
+ },
+
+ _attach: function(r, fromLoader) {
+
+ var mods = YUI.Env.mods,
+ attached = this.Env._attached,
+ i, l = r.length, name, m, d, req, use;
+
+ for (i=0; i<l; i=i+1) {
+
+ name = r[i];
+ m = mods[name];
+
+ if (!attached[name] && m) {
+
+ attached[name] = true;
+
+ d = m.details;
+ req = d.requires;
+ use = d.use;
+
+ if (req) {
+ this._attach(this.Array(req));
+ }
+
+ // this.log('attaching ' + name, 'info', 'yui');
+
+ if (m.fn) {
+ m.fn(this);
+ }
+
+ if (use) {
+ this._attach(this.Array(use));
+ }
+ }
+ }
+
+ },
+
+ /**
+ * Bind a module to a YUI instance
+ * @param modules* {string} 1-n modules to bind (uses arguments array)
+ * @param *callback {function} callback function executed when
+ * the instance has the required functionality. If included, it
+ * must be the last parameter.
+ *
+ * @TODO
+ * Implement versioning? loader can load different versions?
+ * Should sub-modules/plugins be normal modules, or do
+ * we add syntax for specifying these?
+ *
+ * YUI().use('dragdrop')
+ * YUI().use('dragdrop:2.4.0'); // specific version
+ * YUI().use('dragdrop:2.4.0-'); // at least this version
+ * YUI().use('dragdrop:2.4.0-2.9999.9999'); // version range
+ * YUI().use('*'); // use all available modules
+ * YUI().use('lang+dump+substitute'); // use lang and some plugins
+ * YUI().use('lang+*'); // use lang and all known plugins
+ *
+ *
+ * @return {YUI} the YUI instance
+ */
+ use: function() {
+
+ if (this._loading) {
+ this._useQueue = this._useQueue || new this.Queue();
+ this._useQueue.add(SLICE.call(arguments, 0));
+ return this;
+ }
+
+ var Y = this,
+ a=SLICE.call(arguments, 0),
+ mods = YUI.Env.mods,
+ used = Y.Env._used,
+ loader,
+ firstArg = a[0],
+ dynamic = false,
+ callback = a[a.length-1],
+ boot = Y.config.bootstrap,
+ k, i, l, missing = [],
+ r = [],
+ css = Y.config.fetchCSS,
+ f = function(name) {
+
+ // only attach a module once
+ if (used[name]) {
+ // Y.log(name + ' already used', 'info', 'yui');
+ return;
+ }
+
+ var m = mods[name], j, req, use;
+
+ if (m) {
+
+ // Y.log('USING ' + name, 'info', 'yui');
+
+ used[name] = true;
+
+ req = m.details.requires;
+ use = m.details.use;
+ } else {
+
+ // CSS files don't register themselves, see if it has been loaded
+ if (!YUI.Env._loaded[Y.version][name]) {
+ // Y.log('module not found: ' + name, 'info', 'yui');
+ missing.push(name);
+ } else {
+ // probably css
+ // Y.log('module not found BUT HAS BEEN LOADED: ' + name, 'info', 'yui');
+ used[name] = true;
+ }
+ }
+
+ // make sure requirements are attached
+ if (req) {
+ if (Y.Lang.isString(req)) {
+ f(req);
+ } else {
+ for (j = 0; j < req.length; j = j + 1) {
+ // Y.log('using module\'s requirements: ' + name, 'info', 'yui');
+ f(req[j]);
+ }
+ }
+ }
+
+ // add this module to full list of things to attach
+ // Y.log('adding to requires list: ' + name);
+ r.push(name);
+
+ },
+
+ onComplete;
+
+ // Y.log(Y.id + ': use called: ' + a + ' :: ' + callback);
+
+ // The last argument supplied to use can be a load complete callback
+ if (typeof callback === 'function') {
+ a.pop();
+ } else {
+ callback = null;
+ }
+
+ onComplete = function(fromLoader) {
+
+ // Y.log('Use complete');
+
+ fromLoader = fromLoader || {
+ success: true,
+ msg: 'not dynamic'
+ };
+
+ if (callback) {
+ callback(Y, fromLoader);
+ }
+
+ if (Y.fire) {
+ Y.fire('yui:load', Y, fromLoader);
+ }
+
+ // process queued use requests as long until done
+ // or dynamic load happens again.
+ Y._loading = false;
+
+ if (Y._useQueue && Y._useQueue.size() && !Y._loading) {
+ Y.use.apply(Y, Y._useQueue.next());
+ }
+ };
+
+
+ // YUI().use('*'); // bind everything available
+ if (firstArg === "*") {
+ a = [];
+ for (k in mods) {
+ if (mods.hasOwnProperty(k)) {
+ a.push(k);
+ }
+ }
+
+ if (callback) {
+ a.push(callback);
+ }
+
+ return Y.use.apply(Y, a);
+ }
+
+ // Y.log('loader before: ' + a.join(','));
+
+ // use loader to expand dependencies and sort the
+ // requirements if it is available.
+ if (Y.Loader) {
+ dynamic = true;
+ loader = new Y.Loader(Y.config);
+ loader.require(a);
+ loader.ignoreRegistered = true;
+ loader.allowRollup = false;
+ // loader.calculate(null, (css && css == 'force') ? null : 'js');
+ // loader.calculate();
+ loader.calculate(null, (css) ? null : 'js');
+ a = loader.sorted;
+ }
+
+ // Y.log('loader after: ' + a.join(','));
+
+ l = a.length;
+
+ // process each requirement and any additional requirements
+ // the module metadata specifies
+ for (i=0; i<l; i=i+1) {
+ f(a[i]);
+ }
+
+ l = missing.length;
+
+ Y.log('Module requirements: ' + a, 'info', 'yui');
+
+ if (l) {
+ missing = Y.Object.keys(Y.Array.hash(missing));
+ Y.log('Modules missing: ' + missing, 'info', 'yui');
+ }
+
+ // dynamic load
+ if (boot && l && Y.Loader) {
+ Y.log('Using loader to fetch missing dependencies.', 'info', 'yui');
+ Y._loading = true;
+ loader = new Y.Loader(Y.config);
+ loader.onSuccess = onComplete;
+ loader.onFailure = onComplete;
+ loader.onTimeout = onComplete;
+ loader.context = Y;
+ loader.attaching = a;
+ // loader.require(missing);
+ loader.require((css) ? missing : a);
+ loader.insert(null, (css) ? null : 'js');
+ } else if (boot && l && Y.Get && !Y.Env.bootstrapped) {
+ Y.log('Fetching loader: ' + Y.config.base + Y.config.loaderPath, 'info', 'yui');
+ Y._loading = true;
+
+ a = Y.Array(arguments, 0, true);
+ // a.unshift('loader');
+
+ Y.Get.script(Y.config.base + Y.config.loaderPath, {
+ onEnd: function() {
+ Y._loading = false;
+ Y.Env.bootstrapped = true;
+ Y._attach(['loader']);
+ Y.use.apply(Y, a);
+ }
+ });
+
+ return Y;
+
+ } else {
+ if (l) {
+ Y.log('Unable or not configured to fetch missing modules.', 'info', 'yui');
+ }
+ Y.log('Attaching available dependencies.', 'info', 'yui');
+ Y._attach(r);
+ onComplete();
+ }
+
+ return Y; // chain support var yui = YUI().use('dragdrop');
+ },
+
+
+ /**
+ * Returns the namespace specified and creates it if it doesn't exist
+ * <pre>
+ * YUI.namespace("property.package");
+ * YUI.namespace("YAHOO.property.package");
+ * </pre>
+ * Either of the above would create YUI.property, then
+ * YUI.property.package (YAHOO is scrubbed out, this is
+ * to remain compatible with YUI2)
+ *
+ * Be careful when naming packages. Reserved words may work in some browsers
+ * and not others. For instance, the following will fail in Safari:
+ * <pre>
+ * YUI.namespace("really.long.nested.namespace");
+ * </pre>
+ * This fails because "long" is a future reserved word in ECMAScript
+ *
+ * @method namespace
+ * @param {string*} arguments 1-n namespaces to create
+ * @return {object} A reference to the last namespace object created
+ */
+ namespace: function() {
+ var a=arguments, o=null, i, j, d;
+ for (i=0; i<a.length; i=i+1) {
+ d = ("" + a[i]).split(".");
+ o = this;
+ for (j=(d[0] == "YAHOO") ? 1 : 0; j<d.length; j=j+1) {
+ o[d[j]] = o[d[j]] || {};
+ o = o[d[j]];
+ }
+ }
+ return o;
+ },
+
+ // this is replaced if the log module is included
+ log: function() {
+
+ },
+
+ /**
+ * Report an error. The reporting mechanism is controled by
+ * the 'throwFail' configuration attribute. If throwFail is
+ * not specified, the message is written to the Logger, otherwise
+ * a JS error is thrown
+ * @method error
+ * @param msg {string} the error message
+ * @param e {Error} Optional JS error that was caught. If supplied
+ * and throwFail is specified, this error will be re-thrown.
+ * @return {YUI} this YUI instance
+ */
+ error: function(msg, e) {
+ if (this.config.throwFail) {
+ throw (e || new Error(msg));
+ } else {
+ this.message(msg, "error"); // don't scrub this one
+ }
+
+ return this;
+ },
+
+ /**
+ * Generate an id that is unique among all YUI instances
+ * @method guid
+ * @param pre {string} optional guid prefix
+ * @return {string} the guid
+ */
+ guid: function(pre) {
+ var id = this.Env._guidp + (++this.Env._uidx);
+ return (pre) ? (pre + id) : id;
+ },
+
+ /**
+ * Returns a guid associated with an object. If the object
+ * does not have one, a new one is created unless readOnly
+ * is specified.
+ * @method stamp
+ * @param o The object to stamp
+ * @param readOnly {boolean} if true, a valid guid will only
+ * be returned if the object has one assigned to it.
+ * @return {string} The object's guid or null
+ */
+ stamp: function(o, readOnly) {
+
+ if (!o) {
+ return o;
+ }
+
+ var uid = (typeof o === 'string') ? o : o._yuid;
+
+ if (!uid) {
+ uid = this.guid();
+ if (!readOnly) {
+ try {
+ o._yuid = uid;
+ } catch(e) {
+ uid = null;
+ }
+ }
+ }
+
+ return uid;
+ }
+};
+
+// Give the YUI global the same properties as an instance.
+// This makes it so that the YUI global can be used like the YAHOO
+// global was used prior to 3.x. More importantly, the YUI global
+// provides global metadata, so env needs to be configured.
+// @TODO review
+
+ p = YUI.prototype;
+
+ // inheritance utilities are not available yet
+ for (i in p) {
+ // if (1) { // intenionally ignoring hasOwnProperty check
+ YUI[i] = p[i];
+ // }
+ }
+
+ // set up the environment
+ YUI._init();
+
+ // add a window load event at load time so we can capture
+ // the case where it fires before dynamic loading is
+ // complete.
+ add(window, 'load', globalListener);
+
+ YUI.Env.add = add;
+ YUI.Env.remove = remove;
+
+ /*
+ * Subscribe to an event. The signature differs depending on the
+ * type of event you are attaching to.
+ * @method on
+ * @param type {string|function|object} The type of the event. If
+ * this is a function, this is dispatched to the aop system. If an
+ * object, it is parsed for multiple subsription definitions
+ * @param fn {Function} The callback
+ * @param elspec {any} DOM element(s), selector string(s), and or
+ * Node ref(s) to attach DOM related events to (only applies to
+ * DOM events).
+ * @param
+ * @return the event target or a detach handle per 'chain' config
+ */
+
+})();
+
+/**
+ * The config object contains all of the configuration options for
+ * the YUI instance. This object is supplied by the implementer
+ * when instantiating a YUI instance. Some properties have default
+ * values if they are not supplied by the implementer.
+ *
+ * @class config
+ * @static
+ */
+
+/**
+ * Allows the YUI seed file to fetch the loader component and library
+ * metadata to dynamically load additional dependencies.
+ *
+ * @property bootstrap
+ * @type boolean
+ * @default true
+ */
+
+/**
+ * Log to the browser console if debug is on and the browser has a
+ * supported console.
+ *
+ * @property useBrowserConsole
+ * @type boolean
+ * @default true
+ */
+
+/**
+ * A hash of log sources that should be logged. If specified, only log messages from these sources will be logged.
+ *
+ * @property logInclude
+ * @type object
+ */
+
+/**
+ * A hash of log sources that should be not be logged. If specified, all sources are logged if not on this list.
+ *
+ * @property logExclude
+ * @type object
+ */
+
+/**
+ * Set to true if the yui seed file was dynamically loaded in
+ * order to bootstrap components relying on the window load event
+ * and the 'domready' custom event.
+ *
+ * @property injected
+ * @type object
+ */
+
+/**
+ * If throwFail is set, Y.fail will generate or re-throw a JS Error. Otherwise the failure is logged.
+ *
+ * @property throwFail
+ * @type boolean
+ * @default true
+ */
+
+/**
+ * The window/frame that this instance should operate in.
+ *
+ * @property win
+ * @type Window
+ * @default the window hosting YUI
+ */
+
+/**
+ * The document associated with the 'win' configuration.
+ *
+ * @property doc
+ * @type Document
+ * @default the document hosting YUI
+ */
+
+/**
+ * A list of modules that defines the YUI core (overrides the default).
+ *
+ * @property core
+ * @type string[]
+ */
+
+/**
+ * The default date format
+ *
+ * @property dateFormat
+ * @type string
+ */
+
+/**
+ * The default locale
+ *
+ * @property locale
+ * @type string
+ */
+
+/**
+ * The default interval when polling in milliseconds.
+ *
+ * @property pollInterval
+ * @type int
+ * @default 20
+ */
+
+/**
+ * The number of dynamic nodes to insert by default before
+ * automatically removing them. This applies to script nodes
+ * because remove the node will not make the evaluated script
+ * unavailable. Dynamic CSS is not auto purged, because removing
+ * a linked style sheet will also remove the style definitions.
+ *
+ * @property purgethreshold
+ * @type int
+ * @default 20
+ */
+
+/**
+ * The default interval when polling in milliseconds.
+ *
+ * @property windowResizeDelay
+ * @type int
+ * @default 40
+ */
+
+/**
+ * Base directory for dynamic loading
+ *
+ * @property base
+ * @type string
+ */
+
+/**
+ * The secure base dir (not implemented)
+ *
+ * For dynamic loading.
+ *
+ * @property secureBase
+ * @type string
+ */
+
+/**
+ * The YUI combo service base dir. Ex: http://yui.yahooapis.com/combo?
+ *
+ * For dynamic loading.
+ *
+ * @property comboBase
+ * @type string
+ */
+
+/**
+ * The root path to prepend to module names for the combo service. Ex: 3.0.0b1/build/
+ *
+ * For dynamic loading.
+ *
+ * @property root
+ * @type string
+ */
+
+/**
+ * A filter to apply to result urls. This filter will modify the default
+ * path for all modules. The default path for the YUI library is the
+ * minified version of the files (e.g., event-min.js). The filter property
+ * can be a predefined filter or a custom filter. The valid predefined
+ * filters are:
+ * <dl>
+ * <dt>DEBUG</dt>
+ * <dd>Selects the debug versions of the library (e.g., event-debug.js).
+ * This option will automatically include the Logger widget</dd>
+ * <dt>RAW</dt>
+ * <dd>Selects the non-minified version of the library (e.g., event.js).</dd>
+ * </dl>
+ * You can also define a custom filter, which must be an object literal
+ * containing a search expression and a replace string:
+ * <pre>
+ * myFilter: {
+ * 'searchExp': "-min\\.js",
+ * 'replaceStr': "-debug.js"
+ * }
+ * </pre>
+ *
+ * For dynamic loading.
+ *
+ * @property filter
+ * @type string|object
+ */
+
+/**
+ * Hash of per-component filter specification. If specified for a given component,
+ * this overrides the filter config
+ *
+ * For dynamic loading.
+ *
+ * @property filters
+ * @type object
+ */
+
+/**
+ * Use the YUI combo service to reduce the number of http connections
+ * required to load your dependencies.
+ *
+ * For dynamic loading.
+ *
+ * @property combine
+ * @type boolean
+ * @default true if 'base' is not supplied, false if it is.
+ */
+
+/**
+ * A list of modules that should never be dynamically loaded
+ *
+ * @property ignore
+ * @type string[]
+ */
+
+/**
+ * A list of modules that should always be loaded when required, even if already
+ * present on the page.
+ *
+ * @property force
+ * @type string[]
+ */
+
+/**
+ * Node or id for a node that should be used as the insertion point for new nodes
+ * For dynamic loading.
+ *
+ * @property insertBefore
+ * @type string
+ */
+
+/**
+ * charset for dynamic nodes
+ *
+ * @property charset
+ * @type string
+ * @deprecated use jsAttributes cssAttributes
+ */
+
+/**
+ * Object literal containing attributes to add to dynamically loaded script nodes.
+ *
+ * @property jsAttributes
+ * @type string
+ */
+
+/**
+ * Object literal containing attributes to add to dynamically loaded link nodes.
+ *
+ * @property cssAttributes
+ * @type string
+ */
+
+/**
+ * Number of milliseconds before a timeout occurs when dynamically
+ * loading nodes. If not set, there is no timeout.
+ *
+ * @property timeout
+ * @type int
+ */
+
+/**
+ * Callback for the 'CSSComplete' event. When dynamically loading YUI
+ * components with CSS, this property fires when the CSS is finished
+ * loading but script loading is still ongoing. This provides an
+ * opportunity to enhance the presentation of a loading page a little
+ * bit before the entire loading process is done.
+ *
+ * @property onCSS
+ * @type function
+ */
+
+/**
+ * A list of module definitions to add to the list of YUI components.
+ * These components can then be dynamically loaded side by side with
+ * YUI via the use() method.See Loader.addModule for the supported
+ * module metadata.
+ *
+ * @property modules
+ * @type function
+ */
+
+/**
+ * The loader 'path' attribute to the loader itself. This is combined
+ * with the 'base' attribute to dynamically load the loader component
+ * when boostrapping with the get utility alone.
+ *
+ * @property loaderPath
+ * @default loader/loader-min.js
+ */
+
+/**
+ *
+ * Specifies whether or not YUI().use(...) will attempt to load CSS
+ * resources at all. Any truthy value will cause CSS dependencies
+ * to load when fetching script. The special value 'force' will
+ * cause CSS dependencies to be loaded even if no script is needed.
+ *
+ * @property fetchCSS
+ * @default true
+ */
+