var JSONPRequest = Y.JSONPRequest,
                                getByPath    = Y.Object.getValue,
                                noop         = function () {};
                            
                            /**
                             * Adds support for parsing complex callback identifiers from the jsonp url.
                             * This includes callback=foo[1]bar.baz["goo"] as well as referencing methods
                             * in the YUI instance.
                             *
                             * @module jsonp
                             * @submodule jsonp-url
                             * @for JSONPRequest
                             */
                            
                            Y.mix(JSONPRequest.prototype, {
                                /**
                                 * RegExp used by the default URL formatter to insert the generated callback
                                 * name into the JSONP url.  Looks for a query param callback=.  If a value
                                 * is assigned, it will be clobbered.
                                 *
                                 * @property _pattern
                                 * @type RegExp
                                 * @default /\bcallback=.*?(?=&|$)/i
                                 * @protected
                                 */
                                _pattern: /\bcallback=(.*?)(?=&|$)/i,
                            
                                /**
                                 * Template used by the default URL formatter to add the callback function
                                 * name to the url.
                                 *
                                 * @property _template
                                 * @type String
                                 * @default "callback={callback}"
                                 * @protected
                                 */
                                _template: "callback={callback}",
                            
                                /**
                                 * <p>Parses the url for a callback named explicitly in the string.
                                 * Override this if the target JSONP service uses a different query
                                 * parameter or url format.</p>
                                 *
                                 * <p>If the callback is declared inline, the corresponding function will
                                 * be returned.  Otherwise null.</p>
                                 *
                                 * @method _defaultCallback
                                 * @param url {String} the url to search in
                                 * @return {Function} the callback function if found, or null
                                 * @protected
                                 */
                                _defaultCallback: function (url) {
                                    var match = url.match(this._pattern),
                                        keys  = [],
                                        i = 0,
                                        locator, path, callback;
                            
                                    if (match) {
                                        // Strip the ["string keys"] and [1] array indexes
                                        locator = match[1]
                                            .replace(/\[(['"])(.*?)\1\]/g,
                                                function (x, $1, $2) {
                                                    keys[i] = $2;
                                                    return '.@' + (i++);
                                                })
                                            .replace(/\[(\d+)\]/g,
                                                function (x, $1) {
                                                    /*jslint bitwise: true */
                                                    keys[i] = parseInt($1, 10) | 0;
                                                    return '.@' + (i++);
                                                })
                                            .replace(/^\./, ''); // remove leading dot
                            
                                        // Validate against problematic characters.
                                        if (!/[^\w\.\$@]/.test(locator)) {
                                            path = locator.split('.');
                                            for (i = path.length - 1; i >= 0; --i) {
                                                if (path[i].charAt(0) === '@') {
                                                    path[i] = keys[parseInt(path[i].substr(1), 10)];
                                                }
                                            }
                            
                                            // First look for a global function, then the Y, then try the Y
                                            // again from the second token (to support "callback=Y.handler")
                                            callback = getByPath(Y.config.win, path) ||
                                                       getByPath(Y, path) ||
                                                       getByPath(Y, path.slice(1));
                                        }
                                    }
                            
                                    return callback || noop;
                                },
                            
                                /**
                                 * URL formatter that looks for callback= in the url and appends it
                                 * if not present.  The supplied proxy name will be assigned to the query
                                 * param.  Override this method by passing a function as the
                                 * &quot;format&quot; property in the config object to the constructor.
                                 *
                                 * @method _format
                                 * @param url { String } the original url
                                 * @param proxy {String} the function name that will be used as a proxy to
                                 *      the configured callback methods.
                                 * @return {String} fully qualified JSONP url
                                 * @protected
                                 */
                                _format: function (url, proxy) {
                                    var callbackRE = /\{callback\}/,
                                        callback, lastChar;
                            
                                    if (callbackRE.test(url)) {
                                        return url.replace(callbackRE, proxy);
                                    }
                            
                                    callback = this._template.replace(callbackRE, proxy);
                            
                                    if (this._pattern.test(url)) {
                                        return url.replace(this._pattern, callback);
                                    } else {
                                        lastChar = url.slice(-1);
                                        if (lastChar !== '&' && lastChar !== '?') {
                                            url += (url.indexOf('?') > -1) ? '&' : '?';
                                        }
                                        return url + callback;
                                    }
                                }
                            
                            }, true);