/**
 * @class Ext.Function
 *
 * A collection of useful static methods to deal with function callbacks.
 * @singleton
 */
 
Ext.Function = (function() {
// @define Ext.lang.Function
// @define Ext.Function
// @require Ext
// @require Ext.lang.Array
    var lastTime = 0,
        animFrameId,
        animFrameHandlers = [],
        animFrameNoArgs = [],
        idSource = 0,
        animFrameMap = {},
        slice = Array.prototype.slice,
        win = window,
        global = Ext.global,
        // We disable setImmediate in unit tests because it derails internal Jasmine queue
        hasImmediate = !Ext.disableImmediate && !!(global.setImmediate && global.clearImmediate),
        requestAnimFrame = win.requestAnimationFrame || win.webkitRequestAnimationFrame ||
            win.mozRequestAnimationFrame || win.oRequestAnimationFrame ||
            function(callback) {
                var currTime = Ext.now(),
                    timeToCall = Math.max(0, 16 - (currTime - lastTime)),
                    timerFn = function() {
                        callback(currTime + timeToCall);
                    },
                    id;
 
                //<debug>
                timerFn.$origFn = callback.$origFn || callback;
                timerFn.$skipTimerCheck = timerFn.$origFn.$skipTimerCheck;
                //</debug>
                
                id = win.setTimeout(timerFn, timeToCall);
                
                lastTime = currTime + timeToCall;
                
                return id;
            },
        fireHandlers = function() {
            var len = animFrameHandlers.length,
                id, i, handler;
 
            animFrameId = null;
 
            //<debug>
            var timer;
            //</debug>
 
            // Fire all animation frame handlers in one go
            for (= 0; i < len; i++) {
                handler = animFrameHandlers[i];
                id = handler[3];
                
                // Check if this timer has been canceled; its map entry is going to be removed
                if (animFrameMap[id]) {
                    delete animFrameMap[id];
 
                    //<debug>
                    timer = Ext.Timer.get(id, 'raf');
                    if (timer) {
                        timer.tick();
                    }
                    //</debug>
 
                    handler[0].apply(handler[1] || global, handler[2] || animFrameNoArgs);
 
                    //<debug>
                    if (timer) {
                        timer.tock();
                    }
                    //</debug>
                }
            }
 
            // Clear all fired animation frame handlers, don't forget that new handlers
            // could have been created in user handler functions called in the loop above
            animFrameHandlers = animFrameHandlers.slice(len);
        },
        fireElevatedHandlers = function() {
            Ext.elevate(fireHandlers);
        },
 
    ExtFunction = {
        /**
         * A very commonly used method throughout the framework. It acts as a wrapper around another method
         * which originally accepts 2 arguments for `name` and `value`.
         * The wrapped function then allows "flexible" value setting of either:
         *
         * - `name` and `value` as 2 arguments
         * - one single object argument with multiple key - value pairs
         *
         * For example:
         *
         *     var setValue = Ext.Function.flexSetter(function(name, value) {
         *         this[name] = value;
         *     });
         *
         *     // Afterwards
         *     // Setting a single name - value
         *     setValue('name1', 'value1');
         *
         *     // Settings multiple name - value pairs
         *     setValue({
         *         name1: 'value1',
         *         name2: 'value2',
         *         name3: 'value3'
         *     });
         *
         * @param {Function} setter The single value setter method.
         * @param {String} setter.name The name of the value being set.
         * @param {Object} setter.value The value being set.
         * @return {Function} 
         */
        flexSetter: function(setter) {
            return function(name, value) {
                var k, i;
 
                if (name !== null) {
                    if (typeof name !== 'string') {
                        for (in name) {
                            if (name.hasOwnProperty(k)) {
                                setter.call(this, k, name[k]);
                            }
                        }
 
                        if (Ext.enumerables) {
                            for (= Ext.enumerables.length; i--;) {
                                k = Ext.enumerables[i];
                                if (name.hasOwnProperty(k)) {
                                    setter.call(this, k, name[k]);
                                }
                            }
                        }
                    } else {
                        setter.call(this, name, value);
                    }
                }
 
                return this;
            };
        },
 
        /**
         * Create a new function from the provided `fn`, change `this` to the provided scope,
         * optionally overrides arguments for the call. Defaults to the arguments passed by
         * the caller.
         *
         * {@link Ext#bind Ext.bind} is alias for {@link Ext.Function#bind Ext.Function.bind}
         * 
         * **NOTE:** This method is similar to the native `bind()` method. The major difference
         * is in the way the parameters are passed. This method expects an array of parameters,
         * and if supplied, it does not automatically pass forward parameters from the bound
         * function:
         * 
         *      function foo (a, b, c) {
         *          console.log(a, b, c);
         *      }
         *      
         *      var nativeFn = foo.bind(this, 1, 2);
         *      var extFn = Ext.Function.bind(foo, this, [1, 2]);
         *
         *      nativeFn(3); // 1, 2, 3
         *      extFn(3); // 1, 2, undefined
         *
         * This method is unavailable natively on IE8 and IE/Quirks but Ext JS provides a
         * "polyfill" to emulate the important features of the standard `bind` method. In
         * particular, the polyfill only provides binding of "this" and optional arguments.
         * 
         * @param {Function} fn The function to delegate.
         * @param {Object} [scope] The scope (`this` reference) in which the function
         * is executed.
         * **If omitted, defaults to the global environment object (usually the browser `window`).**
         * @param {Array} [args] Overrides arguments for the call. (Defaults to
         * the arguments passed by the caller).
         * @param {Boolean/Number} [appendArgs] if `true` the `args` are appended to the
         * arguments passed to the returned wrapper (by default these arguments are ignored).
         * If a number then the `args` are inserted at the specified position.
         * @return {Function} The bound wrapper function.
         */
        bind: function(fn, scope, args, appendArgs) {
            // Function.prototype.bind is polyfilled in IE8, otherwise native
            if (arguments.length <= 2) {
                return fn.bind(scope);
            }
 
            var method = fn;
 
            return function() {
                var callArgs = args || arguments;
 
                if (appendArgs === true) {
                    callArgs = slice.call(arguments, 0);
                    callArgs = callArgs.concat(args);
                }
                else if (typeof appendArgs === 'number') {
                    callArgs = slice.call(arguments, 0); // copy arguments first
                    Ext.Array.insert(callArgs, appendArgs, args);
                }
 
                return method.apply(scope || global, callArgs);
            };
        },
 
        /**
         * Captures the given parameters for a later call to `Ext.callback`. This binding is
         * most useful for resolving scopes for example to an `Ext.app.ViewController`.
         *
         * The arguments match that of `Ext.callback` except for the `args` which, if provided
         * to this method, are prepended to any arguments supplied by the eventual caller of
         * the returned function.
         *
         * @return {Function} A function that, when called, uses `Ext.callback` to call the
         * captured `callback`.
         * @since 5.0.0
         */
        bindCallback: function (callback, scope, args, delay, caller) {
            return function () {
                var a = slice.call(arguments);
                return Ext.callback(callback, scope, args ? args.concat(a) : a, delay, caller);
            };
        },
 
        /**
         * Create a new function from the provided `fn`, the arguments of which are pre-set to `args`.
         * New arguments passed to the newly created callback when it's invoked are appended after the pre-set ones.
         * This is especially useful when creating callbacks.
         *
         * For example:
         *
         *     var originalFunction = function(){
         *         alert(Ext.Array.from(arguments).join(' '));
         *     };
         *
         *     var callback = Ext.Function.pass(originalFunction, ['Hello', 'World']);
         *
         *     callback(); // alerts 'Hello World'
         *     callback('by Me'); // alerts 'Hello World by Me'
         *
         * {@link Ext#pass Ext.pass} is alias for {@link Ext.Function#pass Ext.Function.pass}
         *
         * @param {Function} fn The original function.
         * @param {Array} args The arguments to pass to new callback.
         * @param {Object} scope (optional) The scope (`this` reference) in which the function is executed.
         * @return {Function} The new callback function.
         */
        pass: function(fn, args, scope) {
            if (!Ext.isArray(args)) {
                if (Ext.isIterable(args)) {
                    args = Ext.Array.clone(args);
                } else {
                    args = args !== undefined ? [args] : [];
                }
            }
 
            return function() {
                var fnArgs = args.slice();
                fnArgs.push.apply(fnArgs, arguments);
                return fn.apply(scope || this, fnArgs);
            };
        },
 
        /**
         * Create an alias to the provided method property with name `methodName` of `object`.
         * Note that the execution scope will still be bound to the provided `object` itself.
         *
         * @param {Object/Function} object
         * @param {String} methodName 
         * @return {Function} aliasFn
         */
        alias: function(object, methodName) {
            return function() {
                return object[methodName].apply(object, arguments);
            };
        },
 
        /**
         * Create a "clone" of the provided method. The returned method will call the given
         * method passing along all arguments and the "this" pointer and return its result.
         *
         * @param {Function} method 
         * @return {Function} cloneFn
         */
        clone: function(method) {
            var newMethod, prop;
            
            newMethod = function() {
                return method.apply(this, arguments);
            };
            
            for (prop in method) {
                if (method.hasOwnProperty(prop)) {
                    newMethod[prop] = method[prop];
                }
            }
            
            return newMethod;
        },
 
        /**
         * Creates an interceptor function. The passed function is called before the original one. If it returns false,
         * the original one is not called. The resulting function returns the results of the original function.
         * The passed function is called with the parameters of the original function. Example usage:
         *
         *     var sayHi = function(name){
         *         alert('Hi, ' + name);
         *     };
         *
         *     sayHi('Fred'); // alerts "Hi, Fred"
         *
         *     // create a new function that validates input without
         *     // directly modifying the original function:
         *     var sayHiToFriend = Ext.Function.createInterceptor(sayHi, function(name){
         *         return name === 'Brian';
         *     });
         *
         *     sayHiToFriend('Fred');  // no alert
         *     sayHiToFriend('Brian'); // alerts "Hi, Brian"
         *
         * @param {Function} origFn The original function.
         * @param {Function} newFn The function to call before the original.
         * @param {Object} [scope] The scope (`this` reference) in which the passed function is executed.
         * **If omitted, defaults to the scope in which the original function is called or the browser window.**
         * @param {Object} [returnValue=null] The value to return if the passed function return `false`.
         * @return {Function} The new function.
         */
        createInterceptor: function(origFn, newFn, scope, returnValue) {
            if (!Ext.isFunction(newFn)) {
                return origFn;
            } else {
                returnValue = Ext.isDefined(returnValue) ? returnValue : null;
                
                return function() {
                    var me = this,
                        args = arguments;
 
                    return (newFn.apply(scope || me || global, args) !== false) ?
                                origFn.apply(me || global, args) : returnValue;
                };
            }
        },
 
        /**
         * Creates a delegate (callback) which, when called, executes after a specific delay.
         *
         * @param {Function} fn The function which will be called on a delay when the returned function is called.
         * Optionally, a replacement (or additional) argument list may be specified.
         * @param {Number} delay The number of milliseconds to defer execution by whenever called.
         * @param {Object} scope (optional) The scope (`this` reference) used by the function at execution time.
         * @param {Array} args (optional) Override arguments for the call. (Defaults to the arguments passed by the caller)
         * @param {Boolean/Number} appendArgs (optional) if True args are appended to call args instead of overriding,
         * if a number the args are inserted at the specified position.
         * @return {Function} A function which, when called, executes the original function after the specified delay.
         */
        createDelayed: function(fn, delay, scope, args, appendArgs) {
            var boundFn = fn;
            
            if (scope || args) {
                boundFn = Ext.Function.bind(fn, scope, args, appendArgs);
            }
 
            return function() {
                var me = this,
                    args = slice.call(arguments),
                    timerFn, timerId;
                
                //<debug>
                var timer;
                //</debug>
 
                timerFn = function() {
                    Ext.elevate(boundFn, me, args
                        //<debug>
                        , timer
                        //</debug>
                    );
                };
 
                timerId = setTimeout(timerFn, delay);
 
                //<debug>
                timerFn.$origFn = fn.$origFn || fn;
                timerFn.$skipTimerCheck = timerFn.$origFn.$skipTimerCheck;
 
                timer = Ext.Timer.created('timeout', timerId, {
                    type: 'createDelayed',
                    fn: fn,
                    timerFn: timerFn
                });
                //</debug>
            };
        },
 
        /**
         * Calls function `fn` after the number of milliseconds specified, optionally with
         * a specific `scope` (`this` pointer).
         *
         * Example usage:
         *
         *     var sayHi = function (name) {
         *         alert('Hi, ' + name);
         *     }
         *
         *     // executes immediately:
         *     sayHi('Fred');
         *
         *     // executes after 2 seconds:
         *     Ext.defer(sayHi, 2000, this, ['Fred']);
         *
         * The following syntax is useful for scheduling anonymous functions:
         *
         *     Ext.defer(function () {
         *         alert('Anonymous');
         *     }, 100);
         *
         * NOTE: The `Ext.Function.defer()` method is an alias for `Ext.defer()`.
         *
         * @param {Function} fn The function to defer.
         * @param {Number} millis The number of milliseconds for the `setTimeout` call
         * (if less than or equal to 0 the function is executed immediately).
         * @param {Object} scope (optional) The scope (`this` reference) in which the function is executed.
         * **If omitted, defaults to the browser window.**
         * @param {Array} [args] Overrides arguments for the call. Defaults to the arguments passed by the caller.
         * @param {Boolean/Number} [appendArgs=false] If `true` args are appended to call args instead of overriding,
         * or, if a number, then the args are inserted at the specified position.
         * @return {Number} The timeout id that can be used with `Ext.undefer`.
         */
        defer: function(fn, millis, scope, args, appendArgs) {
            var timerId = 0,
                timerFn, boundFn;
            
            //<debug>
            var timer;
            //</debug>
            
            if (!scope && !args && !appendArgs) {
                boundFn = fn;
            }
            else {
                boundFn = Ext.Function.bind(fn, scope, args, appendArgs);
            }
            
            if (millis > 0) {
                timerFn = function() {
                    Ext.elevate(boundFn
                        //<debug>
                        , null, null, timer
                        //</debug>
                    );
                };
 
                timerId = setTimeout(timerFn, millis);
 
                //<debug>
                timerFn.$origFn = fn.$origFn || fn;
                timerFn.$skipTimerCheck = timerFn.$origFn.$skipTimerCheck;
 
                timer = Ext.Timer.created('timeout', timerId, {
                    type: 'defer',
                    fn: fn,
                    timerFn: timerFn
                });
                //</debug>
            }
            else {
                boundFn();
            }
            
            return timerId;
        },
 
        /**
         * Calls the function `fn` repeatedly at a given interval, optionally with a
         * specific `scope` (`this` pointer).
         *
         *     var sayHi = function (name) {
         *         console.log('Hi, ' + name);
         *     }
         *
         *     // executes every 2 seconds:
         *     var timerId = Ext.interval(sayHi, 2000, this, ['Fred']);
         *
         * The timer is stopped by:
         *
         *     Ext.uninterval(timerId);
         *
         * NOTE: The `Ext.Function.interval()` method is an alias for `Ext.interval()`.
         *
         * @param {Function} fn The function to defer.
         * @param {Number} millis The number of milliseconds for the `setInterval` call
         * @param {Object} scope (optional) The scope (`this` reference) in which the function is executed.
         * **If omitted, defaults to the browser window.**
         * @param {Array} [args] Overrides arguments for the call. Defaults to the arguments passed by the caller.
         * @param {Boolean/Number} [appendArgs=false] If `true` args are appended to call args instead of overriding,
         * or, if a number, then the args are inserted at the specified position.
         * @return {Number} The interval id that can be used with `Ext.uninterval`.
         */
        interval: function(fn, millis, scope, args, appendArgs) {
            var timerFn, timerId, boundFn;
            
            //<debug>
            var timer;
            //</debug>
            
            boundFn = Ext.Function.bind(fn, scope, args, appendArgs);
            
            timerFn = function() {
                Ext.elevate(boundFn
                    //<debug>
                    , null, null, timer
                    //</debug>
                );
            };
            
            timerId = setInterval(timerFn, millis);
 
            //<debug>
            timerFn.$origFn = boundFn.$origFn || fn;
            timerFn.$skipTimerCheck = timerFn.$origFn.$skipTimerCheck;
 
            timer = Ext.Timer.created('interval', timerId, {
                type: 'interval',
                fn: fn,
                timerFn: timerFn
            });
            //</debug>
 
            return timerId;
        },
 
        /**
         * Create a combined function call sequence of the original function + the passed function.
         * The resulting function returns the results of the original function.
         * The passed function is called with the parameters of the original function. Example usage:
         *
         *     var sayHi = function(name){
         *         alert('Hi, ' + name);
         *     };
         *
         *     sayHi('Fred'); // alerts "Hi, Fred"
         *
         *     var sayGoodbye = Ext.Function.createSequence(sayHi, function(name){
         *         alert('Bye, ' + name);
         *     });
         *
         *     sayGoodbye('Fred'); // both alerts show
         *
         * @param {Function} originalFn The original function.
         * @param {Function} newFn The function to sequence.
         * @param {Object} [scope] The scope (`this` reference) in which the passed function is executed.
         * If omitted, defaults to the scope in which the original function is called or the
         * default global environment object (usually the browser window).
         * @return {Function} The new function.
         */
        createSequence: function(originalFn, newFn, scope) {
            if (!newFn) {
                return originalFn;
            }
            else {
                return function() {
                    var result = originalFn.apply(this, arguments);
                    newFn.apply(scope || this, arguments);
                    return result;
                };
            }
        },
 
        /**
         * Creates a delegate function, optionally with a bound scope which, when called, buffers
         * the execution of the passed function for the configured number of milliseconds.
         * If called again within that period, the impending invocation will be canceled, and the
         * timeout period will begin again.
         *
         * @param {Function} fn The function to invoke on a buffered timer.
         * @param {Number} buffer The number of milliseconds by which to buffer the invocation of the
         * function.
         * @param {Object} [scope] The scope (`this` reference) in which.
         * the passed function is executed. If omitted, defaults to the scope specified by the caller.
         * @param {Array} [args] Override arguments for the call. Defaults to the arguments
         * passed by the caller.
         * @return {Function} A function which invokes the passed function after buffering for the specified time.
         */
        createBuffered: function(fn, buffer, scope, args) {
            var timerId,
                result = function() {
                    var callArgs = args || slice.call(arguments, 0),
                        me = scope || this,
                        timerFn;
                    
                    //<debug>
                    var timer;
                    //</debug>
 
                    if (timerId) {
                        Ext.undefer(timerId);
                    }
 
                    timerFn = function() {
                        Ext.elevate(fn, me, callArgs
                            //<debug>
                            , timer
                            //</debug>
                        );
                    };
 
                    result.timer = timerId = setTimeout(timerFn, buffer);
 
                    //<debug>
                    timerFn.$origFn = fn.$origFn || fn;
                    timerFn.$skipTimerCheck = timerFn.$origFn.$skipTimerCheck;
 
                    timer = Ext.Timer.created('timeout', timerId, {
                        type: 'createBuffered',
                        fn: fn,
                        timerFn: timerFn
                    });
                    //</debug>
                };
 
            return result;
        },
 
        /**
        * Creates a wrapped function that, when invoked, defers execution until the next
        * animation frame
         * @private
         * @param {Function} fn The function to call.
         * @param {Object} [scope] The scope (`this` reference) in which the function is executed. Defaults to the window object.
         * @param {Array} [args] The argument list to pass to the function.
         * @param {Number} [queueStrategy=3] A bit flag that indicates how multiple calls to
         * the returned function within the same animation frame should be handled.
         *
         * - 1: All calls will be queued - FIFO order
         * - 2: Only the first call will be queued
         * - 3: The last call will replace all previous calls
         *
         * @return {Function} 
         */
        createAnimationFrame: function(fn, scope, args, queueStrategy) {
            var boundFn, timerId;
 
            queueStrategy = queueStrategy || 3;
 
            boundFn = function() {
                var timerFn,
                    callArgs = args || slice.call(arguments, 0);
 
                scope = scope || this;
 
                if (queueStrategy === 3 && timerId) {
                    ExtFunction.cancelAnimationFrame(timerId);
                }
 
                if ((queueStrategy & 1) || !timerId) {
                    timerFn = function() {
                        timerId = boundFn.timerId = null;
                        fn.apply(scope, callArgs);
                    };
                    
                    //<debug>
                    timerFn.$origFn = fn.$origFn || fn;
                    timerFn.$skipTimerCheck = timerFn.$origFn.$skipTimerCheck;
                    //</debug>
                    
                    timerId = boundFn.timerId = ExtFunction.requestAnimationFrame(timerFn);
                }
            };
            
            return boundFn;
        },
 
        /**
         * @private
         * Schedules the passed function to be called on the next animation frame.
         * @param {Function} fn The function to call.
         * @param {Object} [scope] The scope (`this` reference) in which the function is executed. Defaults to the window object.
         * @param {Mixed[]} [args] The argument list to pass to the function.
         *
         * @return {Number} Timer id for the new animation frame to use when canceling it.
         */
        requestAnimationFrame: function(fn, scope, args) {
            var id = ++idSource,  // Ids start at 1
                handler = slice.call(arguments, 0);
 
            handler[3] = id;
            animFrameMap[id] = 1; // A flag to indicate that the timer exists
 
            //<debug>
            Ext.Timer.created('raf', id, {
                type: 'raf',
                fn: fn
            });
            //</debug>
 
            // We might be in fireHandlers at this moment but this new entry will not
            // be executed until the next frame
            animFrameHandlers.push(handler);
 
            if (!animFrameId) {
                animFrameId = requestAnimFrame(fireElevatedHandlers);
            }
 
            return id;
        },
 
        cancelAnimationFrame: function (id) {
            // Don't remove any handlers from animFrameHandlers array, because
            // the might be in use at the moment (when cancelAnimationFrame is called).
            // Just remove the handler id from the map so it will not be executed
            delete animFrameMap[id];
 
            //<debug>
            Ext.Timer.cancel('raf', id);
            //</debug>
        },
 
        /**
         * Creates a throttled version of the passed function which, when called repeatedly and
         * rapidly, invokes the passed function only after a certain interval has elapsed since the
         * previous invocation.
         *
         * This is useful for wrapping functions which may be called repeatedly, such as
         * a handler of a mouse move event when the processing is expensive.
         *
         * @param {Function} fn The function to execute at a regular time interval.
         * @param {Number} interval The interval in milliseconds on which the passed function is executed.
         * @param {Object} [scope] The scope (`this` reference) in which
         * the passed function is executed. If omitted, defaults to the scope specified by the caller.
         * @return {Function} A function which invokes the passed function at the specified interval.
         */
        createThrottled: function(fn, interval, scope) {
            var lastCallTime = 0,
                elapsed,
                lastArgs,
                timerId,
                execute = function() {
                    fn.apply(scope, lastArgs);
 
                    lastCallTime = Ext.now();
                    lastArgs = timerId = null;
                };
            
            //<debug>
            execute.$origFn = fn.$origFn || fn;
            execute.$skipTimerCheck = execute.$origFn.$skipTimerCheck;
            //</debug>
 
            return function() {
                // Use scope of last call unless the creator specified a scope
                if (!scope) {
                    scope = this;
                }
                elapsed = Ext.now() - lastCallTime;
                lastArgs = Ext.Array.slice(arguments);
 
                // If this is the first invocation, or the throttle interval has been reached, clear any
                // pending invocation, and call the target function now.
                if (elapsed >= interval) {
                    Ext.undefer(timerId);
                    execute();
                }
                // Throttle interval has not yet been reached. Only set the timer to fire if not already set.
                else if (!timerId) {
                    timerId = Ext.defer(execute, interval - elapsed);
                }
            };
        },
 
        /**
         * Wraps the passed function in a barrier function which will call the passed function after the passed number of invocations.
         * @param {Number} count The number of invocations which will result in the calling of the passed function.
         * @param {Function} fn The function to call after the required number of invocations.
         * @param {Object} scope The scope (`this` reference) in which the function will be called.
         */    
        createBarrier: function(count, fn, scope) {
            var barrierFn = function() {
                if (!--count) {
                    fn.apply(scope, arguments);
                }
            };
            
            //<debug>
            barrierFn.$origFn = fn.$origFn || fn;
            barrierFn.$skipTimerCheck = barrierFn.$origFn.$skipTimerCheck;
            //</debug>
            
            return barrierFn;
        },
 
        /**
         * Adds behavior to an existing method that is executed before the
         * original behavior of the function.  For example:
         * 
         *     var soup = {
         *         contents: [],
         *         add: function(ingredient) {
         *             this.contents.push(ingredient);
         *         }
         *     };
         *     Ext.Function.interceptBefore(soup, "add", function(ingredient){
         *         if (!this.contents.length && ingredient !== "water") {
         *             // Always add water to start with
         *             this.contents.push("water");
         *         }
         *     });
         *     soup.add("onions");
         *     soup.add("salt");
         *     soup.contents; // will contain: water, onions, salt
         * 
         * @param {Object} object The target object
         * @param {String} methodName Name of the method to override
         * @param {Function} fn Function with the new behavior.  It will
         * be called with the same arguments as the original method.  The
         * return value of this function will be the return value of the
         * new method.
         * @param {Object} [scope] The scope to execute the interceptor function. Defaults to the object.
         * @return {Function} The new function just created.
         */
        interceptBefore: function(object, methodName, fn, scope) {
            var method = object[methodName] || Ext.emptyFn;
 
            return (object[methodName] = function() {
                var ret = fn.apply(scope || this, arguments);
                method.apply(this, arguments);
 
                return ret;
            });
        },
 
        /**
         * Adds behavior to an existing method that is executed after the
         * original behavior of the function.  For example:
         * 
         *     var soup = {
         *         contents: [],
         *         add: function(ingredient) {
         *             this.contents.push(ingredient);
         *         }
         *     };
         *     Ext.Function.interceptAfter(soup, "add", function(ingredient){
         *         // Always add a bit of extra salt
         *         this.contents.push("salt");
         *     });
         *     soup.add("water");
         *     soup.add("onions");
         *     soup.contents; // will contain: water, salt, onions, salt
         * 
         * @param {Object} object The target object
         * @param {String} methodName Name of the method to override
         * @param {Function} fn Function with the new behavior.  It will
         * be called with the same arguments as the original method.  The
         * return value of this function will be the return value of the
         * new method.
         * @param {Object} [scope] The scope to execute the interceptor function. Defaults to the object.
         * @return {Function} The new function just created.
         */
        interceptAfter: function(object, methodName, fn, scope) {
            var method = object[methodName] || Ext.emptyFn;
 
            return (object[methodName] = function() {
                method.apply(this, arguments);
                return fn.apply(scope || this, arguments);
            });
        },
        
        interceptAfterOnce: function(object, methodName, fn, scope) {
            var origMethod = object[methodName],
                newMethod;
            
            newMethod = function() {
                var ret;
                
                if (origMethod) {
                    origMethod.apply(this, arguments);
                }
                
                ret = fn.apply(scope || this, arguments);
                
                object[methodName] = origMethod;
                object = methodName = fn = scope = origMethod = newMethod = null;
                
                return ret;
            };
            
            object[methodName] = newMethod;
            
            return newMethod;
        },
 
        makeCallback: function (callback, scope) {
            //<debug>
            if (!scope[callback]) {
                if (scope.$className) {
                    Ext.raise('No method "' + callback + '" on ' + scope.$className);
                }
                Ext.raise('No method "' + callback + '"');
            }
            //</debug>
 
            return function () {
                return scope[callback].apply(scope, arguments);
            };
        },
 
        /**
         * Returns a wrapper function that caches the return value for previously
         * processed function argument(s).
         *
         * For example:
         *
         *      function factorial (value) {
         *          var ret = value;
         *
         *          while (--value > 1) {
         *              ret *= value;
         *          }
         *
         *          return ret;
         *      }
         *
         * Each call to `factorial` will loop and multiply to produce the answer. Using
         * this function we can wrap the above and cache its answers:
         *
         *      factorial = Ext.Function.memoize(factorial);
         *
         * The returned function operates in the same manner as before, but results are
         * stored in a cache to avoid calling the wrapped function when given the same
         * arguments.
         *
         *      var x = factorial(20);  // first time; call real factorial()
         *      var y = factorial(20);  // second time; return value from first call
         *
         * To support multi-argument methods, you will need to provide a `hashFn`.
         *
         *      function permutation (n, k) {
         *          return factorial(n) / factorial(n - k);
         *      }
         *
         *      permutation = Ext.Function.memoize(permutation, null, function (n, k) {
         *          n + '-' + k;
         *      });
         *
         * In this case, the `memoize` of `factorial` is sufficient optimization, but the
         * example is simply to illustrate how to generate a unique key for an expensive,
         * multi-argument method.
         *
         * **IMPORTANT**: This cache is unbounded so be cautious of memory leaks if the
         * `memoize`d function is kept indefinitely or is given an unbounded set of
         * possible arguments.
         *
         * @param {Function} fn Function to wrap.
         * @param {Object} scope Optional scope in which to execute the wrapped function.
         * @param {Function} hashFn Optional function used to compute a hash key for
         * storing the result, based on the arguments to the original function.
         * @return {Function} The caching wrapper function.
         * @since 6.0.0
         */
        memoize: function(fn, scope, hashFn) {
            var memo = {},
                isFunc = hashFn && Ext.isFunction(hashFn);
 
            return function (value) {
                var key = isFunc ? hashFn.apply(scope, arguments) : value;
 
                if (!(key in memo)) {
                    memo[key] = fn.apply(scope, arguments);
                }
 
                return memo[key];
            };
        },
 
        //<debug>
        _stripCommentRe: /(\/\*([^*]|[\r\n]|(\*+([^*/]|[\r\n])))*\*+\/)|(\/\/.*)/g,
        //</debug>
 
        toCode: function (fn) {
            var s = fn ? fn.toString() : '';
 
            //<debug>
            s = s.replace(ExtFunction._stripCommentRe, '');
            //</debug>
 
            return s;
        }
 
        //<debug>
        // This is useful for unit testing so we can force handlers which have been deferred
        // to the next animation frame to run immediately
        ,fireElevatedHandlers: function() {
            fireElevatedHandlers();
        }
        //</debug>
    }; // ExtFunction
 
    /**
     * @member Ext
     * @method asap
     * Schedules the specified callback function to be executed on the next turn of the
     * event loop. Where available, this method uses the browser's `setImmediate` API. If
     * not available, this method substitutes `setTimeout(0)`. Though not a perfect
     * replacement for `setImmediate` it is sufficient for many use cases.
     *
     * For more details see [MDN](https://developer.mozilla.org/en-US/docs/Web/API/Window/setImmediate).
     *
     * @param {Function} fn Callback function.
     * @param {Object} [scope] The scope for the callback (`this` pointer).
     * @param {Mixed[]} [parameters] Additional parameters to pass to `fn`.
     * @return {Number} A cancellation id for `{@link Ext#unasap}`.
     */
    Ext.asap = hasImmediate ?
        function (fn, scope, parameters) {
            var boundFn = fn,
                timerFn, timerId;
            
            //<debug>
            var timer;
            //</debug>
            
            if (scope != null || parameters != null) {
                boundFn = ExtFunction.bind(fn, scope, parameters);
            }
            
            timerFn = function() {
                Ext.elevate(boundFn
                    //<debug>
                    , null, null, timer
                    //</debug>
                );
            };
 
            timerId = setImmediate(timerFn);
            
            //<debug>
            timerFn.$origFn = fn.$origFn || fn;
            timerFn.$skipTimerCheck = timerFn.$origFn.$skipTimerCheck;
 
            timer = Ext.Timer.created('asap', timerId, {
                type: 'asap',
                fn: fn,
                timerFn: timerFn
            });
            //</debug>
            
            return timerId;
        } :
        function (fn, scope, parameters) {
            var boundFn = fn,
                timerFn, timerId;
            
            //<debug>
            var timer;
            //</debug>
                
            if (scope != null || parameters != null) {
                boundFn = ExtFunction.bind(fn, scope, parameters);
            }
            
            timerFn = function() {
                Ext.elevate(boundFn
                    //<debug>
                    , null, null, timer
                    //</debug>
                );
            };
 
            timerId = setTimeout(timerFn, 0, true);
 
            //<debug>
            timerFn.$origFn = fn.$origFn || fn;
            timerFn.$skipTimerCheck = timerFn.$origFn.$skipTimerCheck;
 
            timer = Ext.Timer.created('timeout', timerId, {
                type: 'asap',
                fn: fn,
                timerFn: timerFn
            });
            //</debug>
            
            return timerId;
        };
 
    /**
     * @member Ext
     * @method unasap
     * Cancels a previously scheduled call to `{@link Ext#asap}`.
     *
     *      var timerId = Ext.asap(me.method, me);
     *      ...
     *
     *      if (nevermind) {
     *          Ext.unasap(timerId);
     *      }
     *
     * This method always returns `null` to enable simple cleanup:
     *
     *      timerId = Ext.unasap(timerId);  // safe even if !timerId
     *
     * @param {Number} id The id returned by `{@link Ext#asap}`.
     * @return {Object} Always returns `null`.
     */
    Ext.unasap = hasImmediate ?
        function (id) {
            if (id) {
                clearImmediate(id);
                //<debug>
                Ext.Timer.cancel('asap', id);
                //</debug>
            }
 
            return null;
        } : function (id) {
            return Ext.undefer(id);
        };
 
    /**
     * @member Ext
     * @method asapCancel
     * Cancels a previously scheduled call to `{@link Ext#asap}`.
     * @param {Number} id The id returned by `{@link Ext#asap}`.
     * @deprecated 6.5.1 Use `Ext.unasap` instead.
     */
    Ext.asapCancel = function (id) {
        return Ext.unasap(id);
    };
 
    /**
     * @method defer
     * @member Ext
     * @inheritdoc Ext.Function#defer
     */
    Ext.defer = ExtFunction.defer;
 
    /**
     * @member Ext
     * @method undefer
     * Cancels a previously scheduled call to `{@link Ext#defer}`.
     *
     *      var timerId = Ext.defer(me.method, me);
     *      ...
     *
     *      if (nevermind) {
     *          Ext.undefer(timerId);
     *      }
     *
     * This method always returns `null` to enable simple cleanup:
     *
     *      timerId = Ext.undefer(timerId);  // safe even if !timerId
     *
     * @param {Number} id The id returned by `{@link Ext#defer}`.
     */
    Ext.undefer = function (id) {
        if (id) {
            clearTimeout(id);
 
            //<debug>
            Ext.Timer.cancel('timeout', id);
            //</debug>
        }
 
        return null;
    };
 
    /**
     * @method interval
     * @member Ext
     * @inheritdoc Ext.Function#interval
     */
    Ext.interval = ExtFunction.interval;
 
    /**
     * @member Ext
     * @method uninterval
     * Cancels a previously scheduled call to `{@link Ext#interval}`.
     *
     *      var timerId = Ext.interval(me.method, me);
     *      ...
     *
     *      if (nevermind) {
     *          Ext.uninterval(timerId);
     *      }
     *
     * This method always returns `null` to enable simple cleanup:
     *
     *      timerId = Ext.uninterval(timerId);  // safe even if !timerId
     *
     * @param {Number} id The id returned by `{@link Ext#interval}`.
     */
    Ext.uninterval = function (id) {
        if (id) {
            clearInterval(id);
 
            //<debug>
            Ext.Timer.cancel('interval', id);
            //</debug>
        }
 
        return null;
    };
 
    /**
     * @method pass
     * @member Ext
     * @inheritdoc Ext.Function#pass
     */
    Ext.pass = ExtFunction.pass;
 
    /**
     * @method bind
     * @member Ext
     * @inheritdoc Ext.Function#bind
     */
    Ext.bind = ExtFunction.bind;
 
    Ext.raf = function () {
        return ExtFunction.requestAnimationFrame.apply(ExtFunction, arguments);
    };
 
    Ext.unraf = function (id) {
        ExtFunction.cancelAnimationFrame(id);
    };
 
    return ExtFunction;
})();