diff -r 000000000000 -r 40c8f766c9b8 src/cm/media/js/lib/yui/yui_3.0.0b1/build/oop/oop-debug.js
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/cm/media/js/lib/yui/yui_3.0.0b1/build/oop/oop-debug.js	Mon Nov 23 15:14:29 2009 +0100
@@ -0,0 +1,311 @@
+/*
+Copyright (c) 2009, Yahoo! Inc. All rights reserved.
+Code licensed under the BSD License:
+http://developer.yahoo.net/yui/license.txt
+version: 3.0.0b1
+build: 1163
+*/
+YUI.add('oop', function(Y) {
+
+/**
+ * Supplies object inheritance and manipulation utilities.  This adds
+ * additional functionaity to what is provided in yui-base, and the
+ * methods are applied directly to the YUI instance.  This module
+ * is required for most YUI components.
+ * @module oop
+ */
+
+    var L  = Y.Lang, 
+        A  = Y.Array,
+        OP = Object.prototype;
+
+    /**
+     * The following methods are added to the YUI instance
+     * @class YUI~oop
+     */
+
+    /**
+     * Applies prototype properties from the supplier to the receiver.
+     * The receiver can be a constructor or an instance.
+     * @method augment
+     * @param {Function} r  the object to receive the augmentation
+     * @param {Function} s  the object that supplies the properties to augment
+     * @param ov {boolean} if true, properties already on the receiver
+     * will be overwritten if found on the supplier.
+     * @param wl {string[]} a whitelist.  If supplied, only properties in 
+     * this list will be applied to the receiver.
+     * @param args {Array | Any} arg or arguments to apply to the supplier
+     * constructor when initializing.
+     * @return {object} the augmented object
+     *
+     * @todo constructor optional?
+     * @todo understanding what an instance is augmented with
+     * @TODO best practices for overriding sequestered methods.
+     */
+    Y.augment = function(r, s, ov, wl, args) {
+        var sProto           = s.prototype, 
+            newProto         = null, 
+            construct        = s, 
+            a                = (args) ? Y.Array(args) : [], 
+            rProto           = r.prototype, 
+            target           = rProto || r, 
+            applyConstructor = false,
+            sequestered, replacements, i;
+
+        // working on a class, so apply constructor infrastructure
+        if (rProto && construct) {
+            sequestered  = {};
+            replacements = {};
+            newProto     = {};
+
+            // sequester all of the functions in the supplier and replace with
+            // one that will restore all of them.
+            Y.each(sProto, function(v, k) {
+                replacements[k] = function() {
+
+// Y.log('sequestered function "' + k + '" executed.  Initializing EventTarget');
+// overwrite the prototype with all of the sequestered functions,
+// but only if it hasn't been overridden
+                    for (i in sequestered) {
+                        if (sequestered.hasOwnProperty(i) && (this[i] === replacements[i])) {
+                            // Y.log('... restoring ' + k);
+                            this[i] = sequestered[i];
+                        }
+                    }
+
+                    // apply the constructor
+                    construct.apply(this, a);
+
+                    // apply the original sequestered function
+                    return sequestered[k].apply(this, arguments);
+                };
+
+                if ((!wl || (k in wl)) && (ov || !(k in this))) {
+                    // Y.log('augment: ' + k);
+                    if (L.isFunction(v)) {
+                        // sequester the function
+                        sequestered[k] = v;
+
+// replace the sequestered function with a function that will
+// restore all sequestered functions and exectue the constructor.
+                        this[k] = replacements[k];
+                    } else {
+                        // Y.log('augment() applying non-function: ' + k);
+                        this[k] = v;
+                    }
+
+                }
+
+            }, newProto, true);
+
+        // augmenting an instance, so apply the constructor immediately
+        } else {
+            applyConstructor = true;
+        }
+
+        Y.mix(target, newProto || sProto, ov, wl);
+
+        if (applyConstructor) {
+            s.apply(target, a);
+        }
+
+        return r;
+    };
+
+    /**
+     * Applies object properties from the supplier to the receiver.  If
+     * the target has the property, and the property is an object, the target
+     * object will be augmented with the supplier's value.  If the property
+     * is an array, the suppliers value will be appended to the target.
+     * @method aggregate
+     * @param {Function} r  the object to receive the augmentation
+     * @param {Function} s  the object that supplies the properties to augment
+     * @param ov {boolean} if true, properties already on the receiver
+     * will be overwritten if found on the supplier.
+     * @param wl {string[]} a whitelist.  If supplied, only properties in 
+     * this list will be applied to the receiver.
+     * @return {object} the extended object
+     */
+    Y.aggregate = function(r, s, ov, wl) {
+        return Y.mix(r, s, ov, wl, 0, true);
+    };
+
+    /**
+     * Utility to set up the prototype, constructor and superclass properties to
+     * support an inheritance strategy that can chain constructors and methods.
+     * Static members will not be inherited.
+     *
+     * @method extend
+     * @param {Function} r   the object to modify
+     * @param {Function} s the object to inherit
+     * @param {Object} px prototype properties to add/override
+     * @param {Object} sx static properties to add/override
+     * @return {YUI} the YUI instance
+     */
+    Y.extend = function(r, s, px, sx) {
+        if (!s||!r) {
+            // @TODO error symbols
+            Y.error("extend failed, verify dependencies");
+        }
+
+        var sp = s.prototype, rp=Y.Object(sp);
+        r.prototype=rp;
+
+        rp.constructor=r;
+        r.superclass=sp;
+
+        // assign constructor property
+        if (s != Object && sp.constructor == OP.constructor) {
+            sp.constructor=s;
+        }
+    
+        // add prototype overrides
+        if (px) {
+            Y.mix(rp, px, true);
+        }
+
+        // add object overrides
+        if (sx) {
+            Y.mix(r, sx, true);
+        }
+
+        return r;
+    };
+
+    /**
+     * Executes the supplied function for each item in
+     * a collection.  Supports arrays, objects, and
+     * Y.NodeLists
+     * @method each
+     * @param o the object to iterate
+     * @param f the function to execute.  This function
+     * receives the value, key, and object as parameters
+     * @param proto if true, prototype properties are
+     * iterated on objects
+     * @return {YUI} the YUI instance
+     */
+    Y.each = function(o, f, c, proto) {
+
+        if (o.each && o.item) {
+            return o.each.call(o, f, c);
+        } else {
+            switch (A.test(o)) {
+                case 1:
+                    return A.each(o, f, c);
+                case 2:
+                    return A.each(Y.Array(o, 0, true), f, c);
+                default:
+                    return Y.Object.each(o, f, c, proto);
+            }
+        }
+
+        // return Y.Object.each(o, f, c);
+    };
+
+    /**
+     * Deep obj/array copy.  Functions will are cloned with Y.bind.
+     * Array-like objects are treated as arrays.
+     * primitives are returned untouched.  Optionally a
+     * function can be provided to handle other data types,
+     * filter keys, validate values, etc.
+     *
+     * @method clone
+     * @param o what to clone
+     * @param safe {boolean} if true, objects will not have prototype
+     * items from the source.  If false, it does.  In this case, the
+     * original is initally protected, but the clone is not completely immune
+     * from changes to the source object prototype.  Also, cloned prototype
+     * items that are deleted from the clone will result in the value
+     * of the source prototype to be exposed.  If operating on a non-safe
+     * clone, items should be nulled out rather than deleted.
+     * @TODO review
+     * @param f optional function to apply to each item in a collection
+     *          it will be executed prior to applying the value to
+     *          the new object.  Return false to prevent the copy.
+     * @param c optional execution context for f
+     * @param owner Owner object passed when clone is iterating an
+     * object.  Used to set up context for cloned functions.
+     * @return {Array|Object} the cloned object
+     */
+    Y.clone = function(o, safe, f, c, owner) {
+
+        if (!L.isObject(o)) {
+            return o;
+        }
+
+        var o2;
+
+        switch (L.type(o)) {
+            case 'date':
+                return new Date(o);
+            case 'regexp':
+                return new RegExp(o.source);
+            case 'function':
+                o2 = Y.bind(o, owner);
+                break;
+            case 'array':
+                o2 = [];
+                break;
+            default:
+                o2 = (safe) ? {} : Y.Object(o);
+        }
+
+        Y.each(o, function(v, k) {
+            if (!f || (f.call(c || this, v, k, this, o) !== false)) {
+                this[k] =  Y.clone(v, safe, f, c, this);
+            }
+        }, o2);
+
+        return o2;
+    };
+
+
+    /**
+     * Returns a function that will execute the supplied function in the
+     * supplied object's context, optionally adding any additional
+     * supplied parameters to the beginning of the arguments collection the 
+     * supplied to the function.
+     *
+     * @method bind
+     * @param f {Function|String} the function to bind, or a function name
+     * to execute on the context object
+     * @param c the execution context
+     * @param args* 0..n arguments to include before the arguments the 
+     * function is executed with.
+     * @return {function} the wrapped function
+     */
+    Y.bind = function(f, c) {
+        var xargs = arguments.length > 2 ? Y.Array(arguments, 2, true) : null;
+        return function () {
+            var fn = L.isString(f) ? c[f] : f, 
+                args = (xargs) ? xargs.concat(Y.Array(arguments, 0, true)) : arguments;
+            return fn.apply(c || fn, args);
+        };
+    };
+    
+    /**
+     * Returns a function that will execute the supplied function in the
+     * supplied object's context, optionally adding any additional
+     * supplied parameters to the end of the arguments the function
+     * is executed with.
+     *
+     * @method rbind
+     * @param f {Function|String} the function to bind, or a function name
+     * to execute on the context object
+     * @param c the execution context
+     * @param args* 0..n arguments to append to the end of arguments collection
+     * supplied to the function
+     * @return {function} the wrapped function
+     */
+    Y.rbind = function(f, c) {
+        var xargs = arguments.length > 2 ? Y.Array(arguments, 2, true) : null;
+        return function () {
+            var fn = L.isString(f) ? c[f] : f, 
+                args = (xargs) ? Y.Array(arguments, 0, true).concat(xargs) : arguments;
+            return fn.apply(c || fn, args);
+        };
+    };
+
+
+
+}, '3.0.0b1' );