diff -r d334a616c023 -r e16a97fb364a src/cm/media/js/lib/yui/yui3-3.15.0/build/tree-openable/tree-openable-debug.js
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/cm/media/js/lib/yui/yui3-3.15.0/build/tree-openable/tree-openable-debug.js	Mon Mar 10 15:19:48 2014 +0100
@@ -0,0 +1,241 @@
+YUI.add('tree-openable', function (Y, NAME) {
+
+/*jshint expr:true, onevar:false */
+
+/**
+Extension for `Tree` that adds the concept of open/closed state for nodes.
+
+@module tree
+@submodule tree-openable
+@main tree-openable
+**/
+
+/**
+Extension for `Tree` that adds the concept of open/closed state for nodes.
+
+@class Tree.Openable
+@constructor
+@extensionfor Tree
+**/
+
+/**
+Fired when a node is closed.
+
+@event close
+@param {Tree.Node} node Node being closed.
+@param {String} src Source of the event.
+@preventable _defCloseFn
+**/
+var EVT_CLOSE = 'close';
+
+/**
+Fired when a node is opened.
+
+@event open
+@param {Tree.Node} node Node being opened.
+@param {String} src Source of the event.
+@preventable _defOpenFn
+**/
+var EVT_OPEN = 'open';
+
+function Openable() {}
+
+Openable.prototype = {
+    // -- Lifecycle ------------------------------------------------------------
+    initializer: function () {
+        this.nodeExtensions = this.nodeExtensions.concat(Y.Tree.Node.Openable);
+    },
+
+    // -- Public Methods -------------------------------------------------------
+
+    /**
+    Closes the specified node if it isn't already closed.
+
+    @method closeNode
+    @param {Tree.Node} node Node to close.
+    @param {Object} [options] Options.
+        @param {Boolean} [options.silent=false] If `true`, the `close` event
+            will be suppressed.
+        @param {String} [options.src] Source of the change, to be passed along
+            to the event facade of the resulting event. This can be used to
+            distinguish between changes triggered by a user and changes
+            triggered programmatically, for example.
+    @chainable
+    **/
+    closeNode: function (node, options) {
+        if (node.canHaveChildren && node.isOpen()) {
+            this._fireTreeEvent(EVT_CLOSE, {
+                node: node,
+                src : options && options.src
+            }, {
+                defaultFn: this._defCloseFn,
+                silent   : options && options.silent
+            });
+        }
+
+        return this;
+    },
+
+    /**
+    Opens the specified node if it isn't already open.
+
+    @method openNode
+    @param {Tree.Node} node Node to open.
+    @param {Object} [options] Options.
+        @param {Boolean} [options.silent=false] If `true`, the `open` event
+            will be suppressed.
+        @param {String} [options.src] Source of the change, to be passed along
+            to the event facade of the resulting event. This can be used to
+            distinguish between changes triggered by a user and changes
+            triggered programmatically, for example.
+    @chainable
+    **/
+    openNode: function (node, options) {
+        if (node.canHaveChildren && !node.isOpen()) {
+            this._fireTreeEvent(EVT_OPEN, {
+                node: node,
+                src : options && options.src
+            }, {
+                defaultFn: this._defOpenFn,
+                silent   : options && options.silent
+            });
+        }
+
+        return this;
+    },
+
+    /**
+    Toggles the open/closed state of the specified node, closing it if it's
+    currently open or opening it if it's currently closed.
+
+    @method toggleOpenNode
+    @param {Tree.Node} node Node to toggle.
+    @param {Object} [options] Options.
+        @param {Boolean} [options.silent=false] If `true`, events will be
+            suppressed.
+        @param {String} [options.src] Source of the change, to be passed along
+            to the event facade of the resulting event. This can be used to
+            distinguish between changes triggered by a user and changes
+            triggered programmatically, for example.
+    @chainable
+    **/
+    toggleOpenNode: function (node, options) {
+        return node.isOpen() ? this.closeNode(node, options) :
+            this.openNode(node, options);
+    },
+
+    // -- Default Event Handlers -----------------------------------------------
+
+    /**
+    Default handler for the `close` event.
+
+    @method _defCloseFn
+    @param {EventFacade} e
+    @protected
+    **/
+    _defCloseFn: function (e) {
+        delete e.node.state.open;
+    },
+
+    /**
+    Default handler for the `open` event.
+
+    @method _defOpenFn
+    @param {EventFacade} e
+    @protected
+    **/
+    _defOpenFn: function (e) {
+        e.node.state.open = true;
+    }
+};
+
+Y.Tree.Openable = Openable;
+/**
+@module tree
+@submodule tree-openable
+**/
+
+/**
+`Tree.Node` extension that adds methods useful for nodes in trees that use the
+`Tree.Openable` extension.
+
+@class Tree.Node.Openable
+@constructor
+@extensionfor Tree.Node
+**/
+
+function NodeOpenable() {}
+
+NodeOpenable.prototype = {
+    /**
+    Closes this node if it's currently open.
+
+    @method close
+    @param {Object} [options] Options.
+        @param {Boolean} [options.silent=false] If `true`, the `close` event
+            will be suppressed.
+        @param {String} [options.src] Source of the change, to be passed along
+            to the event facade of the resulting event. This can be used to
+            distinguish between changes triggered by a user and changes
+            triggered programmatically, for example.
+    @chainable
+    **/
+    close: function (options) {
+        this.tree.closeNode(this, options);
+        return this;
+    },
+
+    /**
+    Returns `true` if this node is currently open.
+
+    Note: the root node of a tree is always considered to be open.
+
+    @method isOpen
+    @return {Boolean} `true` if this node is currently open, `false` otherwise.
+    **/
+    isOpen: function () {
+        return !!this.state.open || this.isRoot();
+    },
+
+    /**
+    Opens this node if it's currently closed.
+
+    @method open
+    @param {Object} [options] Options.
+        @param {Boolean} [options.silent=false] If `true`, the `open` event
+            will be suppressed.
+        @param {String} [options.src] Source of the change, to be passed along
+            to the event facade of the resulting event. This can be used to
+            distinguish between changes triggered by a user and changes
+            triggered programmatically, for example.
+    @chainable
+    **/
+    open: function (options) {
+        this.tree.openNode(this, options);
+        return this;
+    },
+
+    /**
+    Toggles the open/closed state of this node, closing it if it's currently
+    open or opening it if it's currently closed.
+
+    @method toggleOpen
+    @param {Object} [options] Options.
+        @param {Boolean} [options.silent=false] If `true`, events will be
+            suppressed.
+        @param {String} [options.src] Source of the change, to be passed along
+            to the event facade of the resulting event. This can be used to
+            distinguish between changes triggered by a user and changes
+            triggered programmatically, for example.
+    @chainable
+    **/
+    toggleOpen: function (options) {
+        this.tree.toggleOpenNode(this, options);
+        return this;
+    }
+};
+
+Y.Tree.Node.Openable = NodeOpenable;
+
+
+}, '@VERSION@', {"requires": ["tree"]});