/*

YUI 3.10.3 (build 2fb5187)

Copyright 2013 Yahoo! Inc. All rights reserved.

Licensed under the BSD License.

http://yuilibrary.com/license/

*/

/**

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

@main yui

@submodule yui-base

**/

/*jshint eqeqeq: false*/

if (typeof YUI != 'undefined') {

    YUI._YUI = YUI;

}

/**

The YUI global namespace object. This is the constructor for all YUI instances.

This is a self-instantiable factory function, meaning you don't need to precede

it with the `new` operator. You can invoke it directly like this:

    YUI().use('*', function (Y) {

        // Y is a new YUI instance.

    });

But it also works like this:

    var Y = YUI();

The `YUI` constructor accepts an optional config object, like this:

    YUI({

        debug: true,

        combine: false

    }).use('node', function (Y) {

        // Y.Node is ready to use.

    });

See the API docs for the <a href="config.html">Config</a> class for the complete

list of supported configuration properties accepted by the YUI constuctor.

If a global `YUI` object is already defined, the existing YUI object will not be

overwritten, to ensure that defined namespaces are preserved.

Each YUI instance has full custom event support, but only if the event system is

available.

@class YUI

@uses EventTarget

@constructor

@global

@param {Object} [config]* Zero or more optional configuration objects. Config

    values are stored in the `Y.config` property. See the

    <a href="config.html">Config</a> docs for the list of supported properties.

**/

    /*global YUI*/

    /*global YUI_config*/

    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 = (typeof YUI_config !== 'undefined') && YUI_config;

        if (!(instanceOf(Y, YUI))) {

            Y = new YUI();

        } else {

            // set up the core environment

            Y._init();

            /**

            Master configuration that might span multiple contexts in a non-

            browser environment. It is applied first to all instances in all

            contexts.

            @example

                YUI.GlobalConfig = {

                    filter: 'debug'

                };

                YUI().use('node', function (Y) {

                    // debug files used here

                });

                YUI({

                    filter: 'min'

                }).use('node', function (Y) {

                    // min files used here

                });

            @property {Object} GlobalConfig

            @global

            @static

            **/

            if (YUI.GlobalConfig) {

                Y.applyConfig(YUI.GlobalConfig);

            }

            /**

            Page-level config applied to all YUI instances created on the

            current page. This is applied after `YUI.GlobalConfig` and before

            any instance-level configuration.

            @example

                // Single global var to include before YUI seed file

                YUI_config = {

                    filter: 'debug'

                };

                YUI().use('node', function (Y) {

                    // debug files used here

                });

                YUI({

                    filter: 'min'

                }).use('node', function (Y) {

                    // min files used here

                });

            @property {Object} YUI_config

            @global

            **/

            if (gconf) {

                Y.applyConfig(gconf);

            }

            // bind the specified additional modules for this instance

            if (!l) {

                Y._setup();

            }

        }

        if (l) {

            // Each instance can accept one or more configuration objects.

            // These are applied after YUI.GlobalConfig and YUI_Config,

            // overriding values set in those config files if there is a

            // matching property.

            for (; i < l; i++) {

                Y.applyConfig(args[i]);

            }

            Y._setup();

        }

        Y.instanceOf = instanceOf;

        return Y;

    };

(function() {

    var proto, prop,

        VERSION = '@VERSION@',

        PERIOD = '.',

        BASE = 'http://yui.yahooapis.com/',

        /*

            These CSS class names can't be generated by

            getClassName since it is not available at the

            time they are being used.

        */

        DOC_LABEL = 'yui3-js-enabled',

        CSS_STAMP_EL = 'yui3-css-stamp',

        NOOP = function() {},

        SLICE = Array.prototype.slice,

        APPLY_TO_AUTH = { 'io.xdrReady': 1,   // the functions applyTo

                          'io.xdrResponse': 1,   // can call. this should

                          'SWF.eventHandler': 1 }, // be done at build time

        hasWin = (typeof window != 'undefined'),

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

            if (el && el.addEventListener) {

                el.addEventListener(type, fn, capture);

            } else if (el && el.attachEvent) {

                el.attachEvent('on' + type, fn);

            }

        },

        remove = function(el, type, fn, capture) {

            if (el && el.removeEventListener) {

                // this can throw an uncaught exception in FF

                try {

                    el.removeEventListener(type, fn, capture);

                } catch (ex) {}

            } else if (el && el.detachEvent) {

                el.detachEvent('on' + type, fn);

            }

        },

        handleLoad = function() {

            YUI.Env.windowLoaded = true;

            YUI.Env.DOMReady = true;

            if (hasWin) {

                remove(window, 'load', handleLoad);

            }

        },

        getLoader = function(Y, o) {

            var loader = Y.Env._loader,

                lCore = [ 'loader-base' ],

                G_ENV = YUI.Env,

                mods = G_ENV.mods;

            if (loader) {

                //loader._config(Y.config);

                loader.ignoreRegistered = false;

                loader.onEnd = null;

                loader.data = null;

                loader.required = [];

                loader.loadType = null;

            } else {

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

                Y.Env._loader = loader;

            }

            if (mods && mods.loader) {

                lCore = [].concat(lCore, YUI.Env.loaderExtras);

            }

            YUI.Env.core = Y.Array.dedupe([].concat(YUI.Env.core, lCore));

            return loader;

        },

        clobber = function(r, s) {

            for (var i in s) {

                if (s.hasOwnProperty(i)) {

                    r[i] = s[i];

                }

            }

        },

        ALREADY_DONE = { success: true };

//  Stamp the documentElement (HTML) with a class of "yui-loaded" to

//  enable styles that need to key off of JS being enabled.

if (docEl && docClass.indexOf(DOC_LABEL) == -1) {

    if (docClass) {

        docClass += ' ';

    }

    docClass += DOC_LABEL;

    docEl.className = docClass;

}

if (VERSION.indexOf('@') > -1) {

    VERSION = '3.5.0'; // dev time hack for cdn test

}

proto = {

    /**

    Applies a new configuration object to the config of this YUI instance. This

    will merge new group/module definitions, and will also update the loader

    cache if necessary. Updating `Y.config` directly will not update the cache.

    @method applyConfig

    @param {Object} o the configuration object.

    @since 3.2.0

    **/

    applyConfig: function(o) {

        o = o || NOOP;

        var attr,

            name,

            // detail,

            config = this.config,

            mods = config.modules,

            groups = config.groups,

            aliases = config.aliases,

            loader = this.Env._loader;

        for (name in o) {

            if (o.hasOwnProperty(name)) {

                attr = o[name];

                if (mods && name == 'modules') {

                    clobber(mods, attr);

                } else if (aliases && name == 'aliases') {

                    clobber(aliases, attr);

                } else if (groups && name == 'groups') {

                    clobber(groups, attr);

                } else if (name == 'win') {

                    config[name] = (attr && attr.contentWindow) || attr;

                    config.doc = config[name] ? config[name].document : null;

                } else if (name == '_yuid') {

                    // preserve the guid

                } else {

                    config[name] = attr;

                }

            }

        }

        if (loader) {

            loader._config(o);

        }

    },

    /**

    Old way to apply a config to this instance (calls `applyConfig` under the

    hood).

    @private

    @method _config

    @param {Object} o The config to apply

    **/

    _config: function(o) {

        this.applyConfig(o);

    },

    /**

    Initializes this YUI instance.

    @private

    @method _init

    **/

    _init: function() {

        var filter, el,

            Y = this,

            G_ENV = YUI.Env,

            Env = Y.Env,

            prop;

        /**

        The version number of this YUI instance.

        This value is typically updated by a script when a YUI release is built,

        so it may not reflect the correct version number when YUI is run from

        the development source tree.

        @property {String} version

        **/

        Y.version = VERSION;

        if (!Env) {

            Y.Env = {

                core: ['get', 'features', 'intl-base', 'yui-log', 'yui-later'],

                loaderExtras: ['loader-rollup', 'loader-yui3'],

                mods: {}, // flat module map

                versions: {}, // version module map

                base: BASE,

                cdn: BASE + VERSION + '/build/',

                // bootstrapped: false,

                _idx: 0,

                _used: {},

                _attached: {},

                _missed: [],

                _yidx: 0,

                _uidx: 0,

                _guidp: 'y',

                _loaded: {},

                // serviced: {},

                // Regex in English:

                // I'll start at the \b(simpleyui).

                // 1. Look in the test string for "simpleyui" or "yui" or

                //    "yui-base" or "yui-davglass" or "yui-foobar" that comes after a word break.  That is, it

                //    can't match "foyui" or "i_heart_simpleyui". This can be anywhere in the string.

                // 2. After #1 must come a forward slash followed by the string matched in #1, so

                //    "yui-base/yui-base" or "simpleyui/simpleyui" or "yui-pants/yui-pants".

                // 3. The second occurence of the #1 token can optionally be followed by "-debug" or "-min",

                //    so "yui/yui-min", "yui/yui-debug", "yui-base/yui-base-debug". NOT "yui/yui-tshirt".

                // 4. This is followed by ".js", so "yui/yui.js", "simpleyui/simpleyui-min.js"

                // 0. Going back to the beginning, now. If all that stuff in 1-4 comes after a "?" in the string,

                //    then capture the junk between the LAST "&" and the string in 1-4.  So

                //    "blah?foo/yui/yui.js" will capture "foo/" and "blah?some/thing.js&3.3.0/build/yui-davglass/yui-davglass.js"

                //    will capture "3.3.0/build/"

                //

                // Regex Exploded:

                // (?:\?             Find a ?

                //   (?:[^&]*&)      followed by 0..n characters followed by an &

                //   *               in fact, find as many sets of characters followed by a & as you can

                //   ([^&]*)         capture the stuff after the last & in \1

                // )?                but it's ok if all this ?junk&more_junk stuff isn't even there

                // \b(simpleyui|     after a word break find either the string "simpleyui" or

                //    yui(?:-\w+)?   the string "yui" optionally followed by a -, then more characters

                // )                 and store the simpleyui or yui-* string in \2

                // \/\2              then comes a / followed by the simpleyui or yui-* string in \2

                // (?:-(min|debug))? optionally followed by "-min" or "-debug"

                // .js               and ending in ".js"

                _BASE_RE: /(?:\?(?:[^&]*&)*([^&]*))?\b(simpleyui|yui(?:-\w+)?)\/\2(?:-(min|debug))?\.js/,

                parseBasePath: function(src, pattern) {

                    var match = src.match(pattern),

                        path, filter;

                    if (match) {

                        path = RegExp.leftContext || src.slice(0, src.indexOf(match[0]));

                        // this is to set up the path to the loader.  The file

                        // filter for loader should match the yui include.

                        filter = match[3];

                        // extract correct path for mixed combo urls

                        // http://yuilibrary.com/projects/yui3/ticket/2528423

                        if (match[1]) {

                            path += '?' + match[1];

                        }

                        path = {

                            filter: filter,

                            path: path

                        };

                    }

                    return path;

                },

                getBase: G_ENV && G_ENV.getBase ||

                        function(pattern) {

                            var nodes = (doc && doc.getElementsByTagName('script')) || [],

                                path = Env.cdn, parsed,

                                i, len, src;

                            for (i = 0, len = nodes.length; i < len; ++i) {

                                src = nodes[i].src;

                                if (src) {

                                    parsed = Y.Env.parseBasePath(src, pattern);

                                    if (parsed) {

                                        filter = parsed.filter;

                                        path = parsed.path;

                                        break;

                                    }

                                }

                            }

                            // use CDN default

                            return path;

                        }

            };

            Env = Y.Env;

            Env._loaded[VERSION] = {};

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

                G_ENV = YUI._YUI.Env;

                Env._yidx += G_ENV._yidx;

                Env._uidx += G_ENV._uidx;

                for (prop in G_ENV) {

                    if (!(prop in Env)) {

                        Env[prop] = G_ENV[prop];

                    }

                }

                delete YUI._YUI;

            }

            Y.id = Y.stamp(Y);

            instances[Y.id] = Y;

        }

        Y.constructor = YUI;

        // configuration defaults

        Y.config = Y.config || {

            bootstrap: true,

            cacheUse: true,

            debug: true,

            doc: doc,

            fetchCSS: true,

            throwFail: true,

            useBrowserConsole: true,

            useNativeES5: true,

            win: win,

            global: Function('return this')()

        };

        //Register the CSS stamp element

        if (doc && !doc.getElementById(CSS_STAMP_EL)) {

            el = doc.createElement('div');

            el.innerHTML = '<div id="' + CSS_STAMP_EL + '" style="position: absolute !important; visibility: hidden !important"></div>';

            YUI.Env.cssStampEl = el.firstChild;

            if (doc.body) {

                doc.body.appendChild(YUI.Env.cssStampEl);

            } else {

                docEl.insertBefore(YUI.Env.cssStampEl, docEl.firstChild);

            }

        } else if (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);

        if (!filter || (!('mindebug').indexOf(filter))) {

            filter = 'min';

        }

        filter = (filter) ? '-' + filter : filter;

        Y.config.loaderPath = YUI.config.loaderPath || 'loader/loader' + filter + '.js';

    },

    /**

    Finishes the instance setup. Attaches whatever YUI modules were defined

    at the time that this instance was created.

    @method _setup

    @private

    **/

    _setup: function() {

        var i, Y = this,

            core = [],

            mods = YUI.Env.mods,

            extras = Y.config.core || [].concat(YUI.Env.core); //Clone it..

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

            if (mods[extras[i]]) {

                core.push(extras[i]);

            }

        }

        Y._attach(['yui-base']);

        Y._attach(core);