191 Async.prototype.setScheduler = function(fn) {  argument
193     this._schedule = fn;
227 Async.prototype.throwLater = function(fn, arg) {  argument
229         arg = fn;
230         fn = function () { throw arg; };  function
234             fn(arg);
238             fn(arg);
245 function AsyncInvokeLater(fn, receiver, arg) {  argument
246     this._lateQueue.push(fn, receiver, arg);
250 function AsyncInvoke(fn, receiver, arg) {  argument
251     this._normalQueue.push(fn, receiver, arg);
265     Async.prototype.invokeLater = function (fn, receiver, arg) {  argument
267             AsyncInvokeLater.call(this, fn, receiver, arg);
271                     fn.call(receiver, arg);
277     Async.prototype.invoke = function (fn, receiver, arg) {  argument
279             AsyncInvoke.call(this, fn, receiver, arg);
282                 fn.call(receiver, arg);
305     var fn = queue.shift();
306     if (typeof fn !== "function") {
307         fn._settlePromises();
311         fn.call(receiver, arg);
437     var fn;
438     if (obj != null) fn = obj[methodName];
439     if (typeof fn !== "function") {
444     return fn;
449     var fn = ensureMethod(obj, methodName);
450     return fn.apply(obj, this);
832 Promise.onPossiblyUnhandledRejection = function (fn) {  argument
835         typeof fn === "function" ? (domain === null ?
836                                             fn : util.domainBind(domain, fn))
840 Promise.onUnhandledRejectionHandled = function (fn) {  argument
843         typeof fn === "function" ? (domain === null ?
844                                             fn : util.domainBind(domain, fn))
1724 function PromiseMapSeries(promises, fn) {  argument
1725     return PromiseReduce(promises, fn, INTERNAL, INTERNAL);
1728 Promise.prototype.each = function (fn) {  argument
1729     return PromiseReduce(this, fn, INTERNAL, 0)
1733 Promise.prototype.mapSeries = function (fn) {  argument
1734     return PromiseReduce(this, fn, INTERNAL, INTERNAL);
1737 Promise.each = function (promises, fn) {  argument
1738     return PromiseReduce(promises, fn, INTERNAL, 0)
1951 Promise.prototype.filter = function (fn, options) {  argument
1952     return PromiseMap(this, fn, options, INTERNAL);
1955 Promise.filter = function (promises, fn, options) {  argument
1956     return PromiseMap(promises, fn, options, INTERNAL);
2314 Promise.coroutine.addYieldHandler = function(fn) {  argument
2315     if (typeof fn !== "function") {
2316         throw new TypeError("expecting a function but got " + util.classString(fn));
2318     yieldHandlers.push(fn);
2348     var fn;
2350         fn = arguments[last];
2354     if (fn) args.pop();
2356     return fn !== undefined ? ret.spread(fn) : ret;
2375 function MappingPromiseArray(promises, fn, limit, _filter) {  argument
2379     this._callback = domain === null ? fn : util.domainBind(domain, fn);
2495 function map(promises, fn, options, _filter) {  argument
2496     if (typeof fn !== "function") {
2497         return apiRejection("expecting a function but got " + util.classString(fn));
2517     return new MappingPromiseArray(promises, fn, limit, _filter).promise();
2520 Promise.prototype.map = function (fn, options) {  argument
2521     return map(this, fn, options, null);
2524 Promise.map = function (promises, fn, options, _filter) {  argument
2525     return map(promises, fn, options, _filter);
2538 Promise.method = function (fn) {  argument
2539     if (typeof fn !== "function") {
2540         throw new Promise.TypeError("expecting a function but got " + util.classString(fn));
2546         var value = tryCatch(fn).apply(this, arguments);
2555 Promise.attempt = Promise["try"] = function (fn) {
2556     if (typeof fn !== "function") {
2557         return apiRejection("expecting a function but got " + util.classString(fn));
2567         value = util.isArray(arg) ? tryCatch(fn).apply(ctx, arg)
2568                                   : tryCatch(fn).call(ctx, arg);
2570         value = tryCatch(fn)();
2789 Promise.prototype.caught = Promise.prototype["catch"] = function (fn) {  argument
2804         fn = arguments[i];
2805         return this.then(undefined, catchFilter(catchInstances, fn, this));
2807     return this.then(undefined, fn);
2835 Promise.prototype.spread = function (fn) {  argument
2836     if (typeof fn !== "function") {
2837         return apiRejection("expecting a function but got " + util.classString(fn));
2839     return this.all()._then(fn, undefined, undefined, APPLY, undefined);
2866 Promise.prototype.error = function (fn) {  argument
2867     return this.caught(util.originatesFromRejection, fn);
2876 Promise.fromNode = Promise.fromCallback = function(fn) {
2881     var result = tryCatch(fn)(nodebackForPromise(ret, multiArgs));
2913 Promise.setScheduler = function(fn) {  argument
2914     if (typeof fn !== "function") {
2915         throw new TypeError("expecting a function but got " + util.classString(fn));
2917     return async.setScheduler(fn);
3699 function isPromisified(fn) {  argument
3701         return fn.__isPromisified__ === true;
3754 function makeNodePromisifiedClosure(callback, receiver, _, fn, __, multiArgs) {  argument
3758         callback = fn;
3767         var fn = nodebackForPromise(promise, multiArgs);
3769             cb.apply(_receiver, withAppended(arguments, fn));
3791         var fn = methods[i+1];
3795                 makeNodePromisified(key, THIS, key, fn, suffix, multiArgs);
3797             var promisified = promisifier(fn, function() {
3799                                            fn, suffix, multiArgs);
3814 Promise.promisify = function (fn, options) {  argument
3815     if (typeof fn !== "function") {
3816         throw new TypeError("expecting a function but got " + util.classString(fn));
3818     if (isPromisified(fn)) {
3819         return fn;
3824     var ret = promisify(fn, receiver, multiArgs);
3825     util.copyDescriptors(fn, ret, propsFilter);
4009 Queue.prototype.push = function (fn, receiver, arg) {  argument
4012         this._pushOne(fn);
4020     this[(j + 0) & wrapMask] = fn;
4120 function ReductionPromiseArray(promises, fn, initialValue, _each) {  argument
4123     this._fn = domain === null ? fn : util.domainBind(domain, fn);
4220 Promise.prototype.reduce = function (fn, initialValue) {  argument
4221     return reduce(this, fn, initialValue, null);
4224 Promise.reduce = function (promises, fn, initialValue, _each) {  argument
4225     return reduce(promises, fn, initialValue, _each);
4236 function reduce(promises, fn, initialValue, _each) {  argument
4237     if (typeof fn !== "function") {
4238         return apiRejection("expecting a function but got " + util.classString(fn));
4240     var array = new ReductionPromiseArray(promises, fn, initialValue, _each);
4259     var fn = tryCatch(array._fn);
4263         ret = fn.call(promise._boundValue(), value, this.index, this.length);
4265         ret = fn.call(promise._boundValue(),
4294                 ? function(fn) { GlobalSetImmediate.call(global, fn); }
4295                 : function(fn) { ProcessNextTick.call(process, fn); };
4299     schedule = function(fn) {  argument
4300         nativePromise.then(fn);
4323         return function schedule(fn) {  argument
4326                 fn();
4333     schedule = function (fn) {
4334         setImmediate(fn);
4337     schedule = function (fn) {
4338         setTimeout(fn, 0);
4919     function FunctionDisposer(fn, promise, context) {  argument
4920         this.constructor$(fn, promise, context);
4925         var fn = this.data();
4926         return fn.call(resource, resource, inspection);
4957         var fn = arguments[len - 1];
4958         if (typeof fn !== "function") {
4959             return apiRejection("expecting a function but got " + util.classString(fn));
5011                 fn = tryCatch(fn);
5013                     ? fn.apply(undefined, inspections) : fn(inspections);
5047     Promise.prototype.disposer = function (fn) {  argument
5048         if (typeof fn === "function") {
5049             return new FunctionDisposer(fn, this, createContext());
5078 function tryCatch(fn) {  argument
5079     tryCatchTarget = fn;
5228 function isClass(fn) {  argument
5230         if (typeof fn === "function") {
5231             var keys = es5.names(fn.prototype);
5237                 thisAssignmentPattern.test(fn + "") && es5.names(fn).length > 0;
15624 		$.fn.dhx_gantt = function(config){