--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/cm/media/js/lib/yui/yui_3.10.3/build/querystring-parse/querystring-parse-debug.js	Tue Jul 16 14:29:46 2013 +0200
@@ -0,0 +1,169 @@
+/*
+YUI 3.10.3 (build 2fb5187)
+Copyright 2013 Yahoo! Inc. All rights reserved.
+Licensed under the BSD License.
+http://yuilibrary.com/license/
+*/
+
+YUI.add('querystring-parse', function (Y, NAME) {
+
+/**
+ * The QueryString module adds support for serializing JavaScript objects into
+ * query strings and parsing JavaScript objects from query strings format.
+ *
+ * The QueryString namespace is added to your YUI instance including static methods
+ * `Y.QueryString.parse(..)` and `Y.QueryString.stringify(..)`.
+ *
+ * The `querystring` module is a alias for `querystring-parse` and
+ * `querystring-stringify`.
+ *
+ * As their names suggest, `querystring-parse` adds support for parsing
+ * Query String data (`Y.QueryString.parse`) and `querystring-stringify` for serializing
+ * JavaScript data into Query Strings (`Y.QueryString.stringify`).  You may choose to
+ * include either of the submodules individually if you don't need the
+ * complementary functionality, or include the rollup for both.
+ *
+ * @module querystring
+ * @main querystring
+*/
+
+/**
+ * Provides Y.QueryString.parse method to accept Query Strings and return native
+ * JavaScript objects.
+ *
+ * @module querystring
+ * @submodule querystring-parse
+*/
+
+/**
+ * The QueryString module adds support for serializing JavaScript objects into
+ * query strings and parsing JavaScript objects from query strings format.
+ * @class QueryString
+ * @static
+ */
+var QueryString = Y.namespace("QueryString"),
+
+// Parse a key=val string.
+// These can get pretty hairy
+// example flow:
+// parse(foo[bar][][bla]=baz)
+// return parse(foo[bar][][bla],"baz")
+// return parse(foo[bar][], {bla : "baz"})
+// return parse(foo[bar], [{bla:"baz"}])
+// return parse(foo, {bar:[{bla:"baz"}]})
+// return {foo:{bar:[{bla:"baz"}]}}
+pieceParser = function (eq) {
+    return function parsePiece (key, val) {
+
+        var sliced, numVal, head, tail, ret;
+
+        if (arguments.length !== 2) {
+            // key=val, called from the map/reduce
+            key = key.split(eq);
+            return parsePiece(
+                QueryString.unescape(key.shift()),
+                QueryString.unescape(key.join(eq))
+            );
+        }
+        key = key.replace(/^\s+|\s+$/g, '');
+        if (Y.Lang.isString(val)) {
+            val = val.replace(/^\s+|\s+$/g, '');
+            // convert numerals to numbers
+            if (!isNaN(val)) {
+                numVal = +val;
+                if (val === numVal.toString(10)) {
+                    val = numVal;
+                }
+            }
+        }
+        sliced = /(.*)\[([^\]]*)\]$/.exec(key);
+        if (!sliced) {
+            ret = {};
+            if (key) {
+                ret[key] = val;
+            }
+            return ret;
+        }
+        // ["foo[][bar][][baz]", "foo[][bar][]", "baz"]
+        tail = sliced[2];
+        head = sliced[1];
+
+        // array: key[]=val
+        if (!tail) {
+            return parsePiece(head, [val]);
+        }
+
+        // obj: key[subkey]=val
+        ret = {};
+        ret[tail] = val;
+        return parsePiece(head, ret);
+    };
+},
+
+// the reducer function that merges each query piece together into one set of params
+mergeParams = function(params, addition) {
+    return (
+        // if it's uncontested, then just return the addition.
+        (!params) ? addition
+        // if the existing value is an array, then concat it.
+        : (Y.Lang.isArray(params)) ? params.concat(addition)
+        // if the existing value is not an array, and either are not objects, arrayify it.
+        : (!Y.Lang.isObject(params) || !Y.Lang.isObject(addition)) ? [params].concat(addition)
+        // else merge them as objects, which is a little more complex
+        : mergeObjects(params, addition)
+    );
+},
+
+// Merge two *objects* together. If this is called, we've already ruled
+// out the simple cases, and need to do the for-in business.
+mergeObjects = function(params, addition) {
+    for (var i in addition) {
+        if (i && addition.hasOwnProperty(i)) {
+            params[i] = mergeParams(params[i], addition[i]);
+        }
+    }
+    return params;
+};
+
+/**
+ * Accept Query Strings and return native JavaScript objects.
+ *
+ * @method parse
+ * @param qs {String} Querystring to be parsed into an object.
+ * @param sep {String} (optional) Character that should join param k=v pairs together. Default: "&"
+ * @param eq  {String} (optional) Character that should join keys to their values. Default: "="
+ * @public
+ * @static
+ */
+QueryString.parse = function (qs, sep, eq) {
+    // wouldn't Y.Array(qs.split()).map(pieceParser(eq)).reduce(mergeParams) be prettier?
+    return Y.Array.reduce(
+        Y.Array.map(
+            qs.split(sep || "&"),
+            pieceParser(eq || "=")
+        ),
+        {},
+        mergeParams
+    );
+};
+
+/**
+ * Provides Y.QueryString.unescape method to be able to override default decoding
+ * method.  This is important in cases where non-standard delimiters are used, if
+ * the delimiters would not normally be handled properly by the builtin
+ * (en|de)codeURIComponent functions.
+ * Default: replace "+" with " ", and then decodeURIComponent behavior.
+ *
+ * @method unescape
+ * @param s {String} String to be decoded.
+ * @public
+ * @static
+ **/
+QueryString.unescape = function (s) {
+    return decodeURIComponent(s.replace(/\+/g, ' '));
+};
+
+
+
+
+}, '3.10.3', {"requires": ["yui-base", "array-extras"]});