/**
                                The `base-observable` submodule adds observability to Base's lifecycle and
                                attributes, and also make it an `EventTarget`.
                            
                                @module base
                                @submodule base-observable
                                **/
                                var L = Y.Lang,
                            
                                    DESTROY = "destroy",
                                    INIT = "init",
                            
                                    BUBBLETARGETS = "bubbleTargets",
                                    _BUBBLETARGETS = "_bubbleTargets",
                            
                                    AttributeObservable = Y.AttributeObservable,
                                    BaseCore            = Y.BaseCore;
                            
                                /**
                                Provides an augmentable implementation of lifecycle and attribute events for
                                `BaseCore`.
                            
                                @class BaseObservable
                                @extensionfor BaseCore
                                @uses AttributeObservable
                                @uses EventTarget
                                @since 3.8.0
                                **/
                                function BaseObservable() {}
                            
                                BaseObservable._ATTR_CFG      = AttributeObservable._ATTR_CFG.concat();
                                BaseObservable._NON_ATTRS_CFG = ["on", "after", "bubbleTargets"];
                            
                                BaseObservable.prototype = {
                            
                                    /**
                                     * Initializes Attribute
                                     *
                                     * @method _initAttribute
                                     * @private
                                     */
                                    _initAttribute: function() {
                                        BaseCore.prototype._initAttribute.apply(this, arguments);
                                        AttributeObservable.call(this);
                            
                                        this._eventPrefix = this.constructor.EVENT_PREFIX || this.constructor.NAME;
                                        this._yuievt.config.prefix = this._eventPrefix;
                                    },
                            
                                    /**
                                     * Init lifecycle method, invoked during construction.
                                     * Fires the init event prior to setting up attributes and
                                     * invoking initializers for the class hierarchy.
                                     *
                                     * @method init
                                     * @chainable
                                     * @param {Object} config Object with configuration property name/value pairs
                                     * @return {Base} A reference to this object
                                     */
                                    init: function(config) {
                            
                                        /**
                                         * <p>
                                         * Lifecycle event for the init phase, fired prior to initialization.
                                         * Invoking the preventDefault() method on the event object provided
                                         * to subscribers will prevent initialization from occuring.
                                         * </p>
                                         * <p>
                                         * Subscribers to the "after" momemt of this event, will be notified
                                         * after initialization of the object is complete (and therefore
                                         * cannot prevent initialization).
                                         * </p>
                                         *
                                         * @event init
                                         * @preventable _defInitFn
                                         * @param {EventFacade} e Event object, with a cfg property which
                                         * refers to the configuration object passed to the constructor.
                                         */
                            
                                        // PERF: Using lower level _publish() for
                                        // critical path performance
                            
                                        var type = this._getFullType(INIT),
                                            e = this._publish(type);
                            
                                        e.emitFacade = true;
                                        e.fireOnce = true;
                                        e.defaultTargetOnly = true;
                                        e.defaultFn = this._defInitFn;
                            
                                        this._preInitEventCfg(config);
                            
                                        if (e._hasPotentialSubscribers()) {
                                            this.fire(type, {cfg: config});
                                        } else {
                            
                                            this._baseInit(config);
                            
                                            // HACK. Major hack actually. But really fast for no-listeners.
                                            // Since it's fireOnce, subscribers may come along later, so since we're
                                            // bypassing the event stack the first time, we need to tell the published
                                            // event that it's been "fired". Could extract it into a CE method?
                                            e.fired = true;
                                            e.firedWith = [{cfg:config}];
                                        }
                            
                                        return this;
                                    },
                            
                                    /**
                                     * Handles the special on, after and target properties which allow the user to
                                     * easily configure on and after listeners as well as bubble targets during
                                     * construction, prior to init.
                                     *
                                     * @private
                                     * @method _preInitEventCfg
                                     * @param {Object} config The user configuration object
                                     */
                                    _preInitEventCfg : function(config) {
                                        if (config) {
                                            if (config.on) {
                                                this.on(config.on);
                                            }
                                            if (config.after) {
                                                this.after(config.after);
                                            }
                                        }
                            
                                        var i, l, target,
                                            userTargets = (config && BUBBLETARGETS in config);
                            
                                        if (userTargets || _BUBBLETARGETS in this) {
                                            target = userTargets ? (config && config.bubbleTargets) : this._bubbleTargets;
                            
                                            if (L.isArray(target)) {
                                                for (i = 0, l = target.length; i < l; i++) {
                                                    this.addTarget(target[i]);
                                                }
                                            } else if (target) {
                                                this.addTarget(target);
                                            }
                                        }
                                    },
                            
                                    /**
                                     * <p>
                                     * Destroy lifecycle method. Fires the destroy
                                     * event, prior to invoking destructors for the
                                     * class hierarchy.
                                     * </p>
                                     * <p>
                                     * Subscribers to the destroy
                                     * event can invoke preventDefault on the event object, to prevent destruction
                                     * from proceeding.
                                     * </p>
                                     * @method destroy
                                     * @return {Base} A reference to this object
                                     * @chainable
                                     */
                                    destroy: function() {
                                        Y.log('destroy called', 'life', 'base');
                            
                                        /**
                                         * <p>
                                         * Lifecycle event for the destroy phase,
                                         * fired prior to destruction. Invoking the preventDefault
                                         * method on the event object provided to subscribers will
                                         * prevent destruction from proceeding.
                                         * </p>
                                         * <p>
                                         * Subscribers to the "after" moment of this event, will be notified
                                         * after destruction is complete (and as a result cannot prevent
                                         * destruction).
                                         * </p>
                                         * @event destroy
                                         * @preventable _defDestroyFn
                                         * @param {EventFacade} e Event object
                                         */
                                        this.publish(DESTROY, {
                                            fireOnce:true,
                                            defaultTargetOnly:true,
                                            defaultFn: this._defDestroyFn
                                        });
                                        this.fire(DESTROY);
                            
                                        this.detachAll();
                                        return this;
                                    },
                            
                                    /**
                                     * Default init event handler
                                     *
                                     * @method _defInitFn
                                     * @param {EventFacade} e Event object, with a cfg property which
                                     * refers to the configuration object passed to the constructor.
                                     * @protected
                                     */
                                    _defInitFn : function(e) {
                                        this._baseInit(e.cfg);
                                    },
                            
                                    /**
                                     * Default destroy event handler
                                     *
                                     * @method _defDestroyFn
                                     * @param {EventFacade} e Event object
                                     * @protected
                                     */
                                    _defDestroyFn : function(e) {
                                        this._baseDestroy(e.cfg);
                                    }
                                };
                            
                                Y.mix(BaseObservable, AttributeObservable, false, null, 1);
                            
                                Y.BaseObservable = BaseObservable;